Deploy to HF Spaces

.dockerignore

@@ -0,0 +1,38 @@
+# Version control
+.git/
+
+# Virtual environments
+.venv/
+
+# Node modules (reinstalled in build)
+node_modules/
+
+# Build outputs (rebuilt in Docker)
+src/aspara/dashboard/static/dist/
+
+# Test artifacts
+test-results/
+playwright-report/
+.coverage
+htmlcov/
+coverage/
+
+# Documentation build
+site/
+docs/
+
+# IDE / OS
+.idea/
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+
+# Cache
+.mypy_cache/
+.ruff_cache/
+__pycache__/
+
+# Environment files
+.env
+.env.*

.github/workflows/ci.yml

@@ -0,0 +1,96 @@
+name: CI
+
+# Security note for public repositories:
+# If this repository becomes public, configure the following in
+# Settings > Actions > General > "Fork pull request workflows from outside collaborators":
+# Set to "Require approval for all outside collaborators"
+
+on:
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - run: uv sync --dev --locked
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10.6.3
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'pnpm'
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm lint
+
+  python-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.14']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10.6.3
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'pnpm'
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm build
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync --dev --locked
+      - run: uv run pytest --cov=src/aspara --cov-report=xml --cov-report=term-missing
+      - uses: codecov/codecov-action@v4
+        with:
+          files: ./coverage.xml
+          flags: python
+          fail_ci_if_error: false
+
+  js-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10.6.3
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'pnpm'
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm test:ci
+      - uses: codecov/codecov-action@v4
+        with:
+          files: ./coverage/coverage-final.json
+          flags: javascript
+          fail_ci_if_error: false
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10.6.3
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'pnpm'
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm build

.github/workflows/hf-deploy.yml

@@ -0,0 +1,47 @@
+name: Deploy to HF Spaces
+
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+      - "docs/**"
+      - "mkdocs.yml"
+      - "tests/**"
+      - "*.md"
+  workflow_dispatch:
+
+concurrency:
+  group: hf-deploy
+  cancel-in-progress: true
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Fetch HF Space config
+        run: |
+          git fetch origin hf-space
+          git checkout origin/hf-space -- Dockerfile .dockerignore space_README.md
+
+      - name: Prepare HF Space
+        run: |
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config user.name "github-actions[bot]"
+
+          # Create orphan branch (no history) to avoid binary files in past commits
+          git checkout --orphan hf-deploy
+          git rm -rf --cached docs/ tests/ >/dev/null 2>&1 || true
+          rm -rf docs/ tests/
+          cp space_README.md README.md
+          git add -A
+          git commit -m "Deploy to HF Spaces"
+
+      - name: Push to Hugging Face
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git push --force \
+            https://hf:${HF_TOKEN}@huggingface.co/spaces/PredNext/aspara \
+            HEAD:main

.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+dist/
+build/
+*.whl
+
+# Virtual environment
+.venv/
+
+# Node.js
+node_modules/
+
+# Build output
+src/aspara/dashboard/static/dist/
+
+# Test
+test-results/
+playwright-report/
+.coverage
+htmlcov/
+coverage/
+
+# Logs
+logs/
+*.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+*.swp
+*.swo
+
+# Linter / Type checker cache
+.mypy_cache/
+.ruff_cache/
+
+# Environment variables
+.env
+.env.*
+
+# Database
+*.sqlite
+*.db
+
+# uv
+.python-version
+
+# MkDocs
+site/

.readthedocs.yml

@@ -0,0 +1,16 @@
+version: 2
+
+build:
+  os: "ubuntu-24.04"
+  tools:
+    python: "3.12"
+
+mkdocs:
+  configuration: mkdocs.yml
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

DEVELOPMENT.md

@@ -0,0 +1,114 @@
+# Development Guide
+
+This document is a developer guide for Aspara.
+
+## Setup
+
+### Python dependencies
+
+```bash
+uv sync --dev
+```
+
+### JavaScript dependencies
+
+```bash
+pnpm install
+```
+
+## Building Assets
+
+After cloning the repository, you must build frontend assets before running Aspara.
+These build artifacts are not tracked in git, but are included in pip packages.
+
+### Build all assets (CSS + JavaScript)
+
+```bash
+pnpm build
+```
+
+This command generates:
+- CSS: `src/aspara/dashboard/static/dist/css/styles.css`
+- JavaScript: `src/aspara/dashboard/static/dist/*.js`
+
+### Build CSS only
+
+```bash
+pnpm run build:css
+```
+
+### Build JavaScript only
+
+```bash
+pnpm run build:js
+```
+
+### Development mode (watch mode)
+
+To automatically detect file changes and rebuild during development:
+
+```bash
+# Watch CSS
+pnpm run watch:css
+
+# Watch JavaScript
+pnpm run watch:js
+```
+
+## Testing
+
+### Python tests
+
+```bash
+uv run pytest
+```
+
+### JavaScript tests
+
+```bash
+pnpm test
+```
+
+### E2E tests
+
+```bash
+npx playwright test
+```
+
+## Linting and Formatting
+
+### Python
+
+```bash
+# Lint
+ruff check .
+
+# Format
+ruff format .
+```
+
+### JavaScript
+
+```bash
+# Lint
+pnpm lint
+
+# Format
+pnpm format
+```
+
+## Documentation
+
+### Build documentation
+
+```bash
+uv run mkdocs build
+```
+
+### Serve documentation locally
+
+```bash
+uv run mkdocs serve
+```
+
+You can view the documentation by accessing http://localhost:8000 in your browser.

Dockerfile

@@ -0,0 +1,63 @@
+# ==============================================================================
+# Aspara Demo - Hugging Face Spaces
+# Multi-stage build: frontend (Node.js) + backend (Python/FastAPI)
+# ==============================================================================
+
+# ------------------------------------------------------------------------------
+# Stage 1: Frontend build (JS + CSS + icons)
+# ------------------------------------------------------------------------------
+FROM node:22-slim AS frontend-builder
+
+WORKDIR /app
+
+# Enable pnpm via corepack
+RUN corepack enable && corepack prepare pnpm@10.6.3 --activate
+
+# Install JS dependencies (cache layer)
+COPY package.json pnpm-lock.yaml ./
+RUN pnpm install --frozen-lockfile
+
+# Copy source and build frontend assets
+COPY vite.config.js icons.config.json ./
+COPY scripts/ ./scripts/
+COPY src/aspara/dashboard/ ./src/aspara/dashboard/
+RUN pnpm run build:icons && pnpm run build:js && pnpm run build:css
+
+# ------------------------------------------------------------------------------
+# Stage 2: Python runtime + sample data generation
+# ------------------------------------------------------------------------------
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+# Copy Python project files
+COPY pyproject.toml uv.lock ./
+COPY space_README.md ./README.md
+COPY src/ ./src/
+
+# Install Python dependencies (dashboard extra only, no dev deps)
+RUN uv sync --frozen --extra dashboard --no-dev
+
+# Overwrite with built frontend assets
+COPY --from=frontend-builder /app/src/aspara/dashboard/static/dist/ ./src/aspara/dashboard/static/dist/
+
+# Generate sample data during build
+COPY examples/generate_random_runs.py ./examples/
+ENV ASPARA_DATA_DIR=/data/aspara
+ENV ASPARA_ALLOW_IFRAME=1
+ENV ASPARA_READ_ONLY=1
+RUN mkdir -p /data/aspara && uv run python examples/generate_random_runs.py
+
+# Create non-root user (HF Spaces best practice)
+RUN useradd -m -u 1000 user && \
+    chown -R user:user /data /app
+USER user
+
+# HF Spaces uses port 7860
+EXPOSE 7860
+
+# Start dashboard only (no tracker = no external write API)
+CMD ["uv", "run", "aspara", "serve", "--host", "0.0.0.0", "--port", "7860", "--data-dir", "/data/aspara"]

LICENSE

@@ -0,0 +1,178 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no theory of
+      liability, whether in contract, strict liability, or tort
+      (including negligence or otherwise) arising in any way out of
+      the use or inability to use the Work (even if such Holder has
+      been advised of the possibility of such damages), shall any
+      Contributor be liable to You for damages, including any direct,
+      indirect, special, incidental, or consequential damages of any
+      character arising as a result of this License or out of the use
+      or inability to use the Work (including but not limited to
+      damages for loss of goodwill, work stoppage, computer failure or
+      malfunction, or any and all other commercial damages or losses),
+      even if such Contributor has been advised of the possibility of
+      such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

README.md

@@ -0,0 +1,27 @@
+---
+title: Aspara Demo
+emoji: 🌱
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Aspara Demo
+
+Aspara — a blazingly fast metrics tracker for machine learning experiments.
+
+This Space runs a demo dashboard with pre-generated sample data.
+Browse projects, compare runs, and explore metrics to see what Aspara can do.
+
+## Features
+
+- LTTB-based metric downsampling for responsive charts
+- Run comparison with overlay charts
+- Tag and note editing
+- Real-time updates via SSE
+
+## Links
+
+- [GitHub Repository](https://github.com/prednext/aspara)

benchmarks/bench_metrics_api.py

@@ -0,0 +1,200 @@
+"""Benchmark for the /api/projects/{project}/runs/metrics endpoint.
+
+Measures response time and size for both JSON and msgpack formats.
+Uses httpx AsyncClient with ASGITransport so no server process is needed.
+
+Usage:
+    uv run python benchmarks/bench_metrics_api.py
+    uv run python benchmarks/bench_metrics_api.py --runs 10 --metrics 20 --steps 2000
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import statistics
+import tempfile
+import time
+from pathlib import Path
+
+import httpx
+import msgpack
+
+from aspara.dashboard.dependencies import configure_data_dir
+from aspara.dashboard.main import app
+
+
+def create_test_data(data_dir: Path, n_runs: int, n_metrics: int, n_steps: int) -> str:
+    """Create test JSONL data files.
+
+    Returns:
+        Project name used for the test data.
+    """
+    project = "bench_project"
+    project_dir = data_dir / project
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    base_ts = 1700000000000  # Fixed base timestamp in ms
+
+    for r in range(n_runs):
+        run_name = f"run_{r}"
+        run_file = project_dir / f"{run_name}.jsonl"
+        meta_file = project_dir / f"{run_name}.meta.json"
+
+        # Write metrics JSONL
+        with run_file.open("w") as f:
+            for s in range(n_steps):
+                entry = {
+                    "timestamp": base_ts + s * 1000,
+                    "step": s,
+                    "metrics": {f"metric_{m}": s * 0.1 + m for m in range(n_metrics)},
+                }
+                f.write(json.dumps(entry) + "\n")
+
+        # Write minimal metadata
+        meta = {
+            "run_id": run_name,
+            "tags": [],
+            "notes": "",
+            "params": {},
+            "config": {},
+            "artifacts": [],
+            "summary": {},
+            "is_finished": True,
+            "exit_code": 0,
+            "start_time": base_ts,
+            "finish_time": base_ts + n_steps * 1000,
+        }
+        meta_file.write_text(json.dumps(meta))
+
+    return project
+
+
+async def bench_endpoint(
+    client: httpx.AsyncClient,
+    url: str,
+    n_warmup: int = 3,
+    n_iterations: int = 20,
+) -> tuple[list[float], int]:
+    """Benchmark a single endpoint.
+
+    Returns:
+        (list of response times in ms, response size in bytes)
+    """
+    # Warmup
+    for _ in range(n_warmup):
+        resp = await client.get(url, headers={"X-Requested-With": "benchmark"})
+        assert resp.status_code == 200, f"Status {resp.status_code}: {resp.text[:200]}"
+
+    # Measure
+    times: list[float] = []
+    size = 0
+    for _ in range(n_iterations):
+        start = time.perf_counter()
+        resp = await client.get(url, headers={"X-Requested-With": "benchmark"})
+        elapsed = (time.perf_counter() - start) * 1000  # ms
+        times.append(elapsed)
+        size = len(resp.content)
+
+    return times, size
+
+
+def bench_serialization_only(data: dict, n_iterations: int = 100) -> dict[str, list[float]]:
+    """Benchmark raw serialization of the metrics dict.
+
+    Returns:
+        Dict mapping format name to list of times in ms.
+    """
+    results: dict[str, list[float]] = {}
+
+    # JSON via stdlib
+    json_times: list[float] = []
+    for _ in range(n_iterations):
+        start = time.perf_counter()
+        json.dumps(data)
+        elapsed = (time.perf_counter() - start) * 1000
+        json_times.append(elapsed)
+    results["json (stdlib)"] = json_times
+
+    # msgpack
+    msgpack_times: list[float] = []
+    for _ in range(n_iterations):
+        start = time.perf_counter()
+        msgpack.packb(data, use_single_float=True)
+        elapsed = (time.perf_counter() - start) * 1000
+        msgpack_times.append(elapsed)
+    results["msgpack"] = msgpack_times
+
+    return results
+
+
+def print_stats(label: str, times: list[float], size_kb: float | None = None) -> None:
+    """Print timing statistics."""
+    median = statistics.median(times)
+    p95 = sorted(times)[int(len(times) * 0.95)]
+    mean = statistics.mean(times)
+    size_str = f"  size={size_kb:.1f}KB" if size_kb is not None else ""
+    print(f"  {label:30s}  median={median:7.2f}ms  p95={p95:7.2f}ms  mean={mean:7.2f}ms{size_str}")
+
+
+async def main() -> None:
+    parser = argparse.ArgumentParser(description="Benchmark metrics API endpoint")
+    parser.add_argument("--runs", type=int, default=5, help="Number of runs (default: 5)")
+    parser.add_argument("--metrics", type=int, default=10, help="Number of metrics per run (default: 10)")
+    parser.add_argument("--steps", type=int, default=1000, help="Number of steps per metric (default: 1000)")
+    parser.add_argument("--iterations", type=int, default=20, help="Number of benchmark iterations (default: 20)")
+    args = parser.parse_args()
+
+    print(f"Benchmark config: {args.runs} runs x {args.metrics} metrics x {args.steps} steps")
+    print(f"Iterations: {args.iterations}")
+    print()
+
+    with tempfile.TemporaryDirectory() as tmp:
+        data_dir = Path(tmp)
+        project = create_test_data(data_dir, args.runs, args.metrics, args.steps)
+        configure_data_dir(str(data_dir))
+
+        try:
+            run_names = ",".join(f"run_{r}" for r in range(args.runs))
+
+            transport = httpx.ASGITransport(app=app)
+            async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
+                url_json = f"/api/projects/{project}/runs/metrics?runs={run_names}&format=json"
+                url_msgpack = f"/api/projects/{project}/runs/metrics?runs={run_names}&format=msgpack"
+
+                print("--- Endpoint response time ---")
+                json_times, json_size = await bench_endpoint(client, url_json, n_iterations=args.iterations)
+                msgpack_times, msgpack_size = await bench_endpoint(client, url_msgpack, n_iterations=args.iterations)
+
+                print_stats("JSON (Pydantic+Rust)", json_times, json_size / 1024)
+                print_stats("msgpack", msgpack_times, msgpack_size / 1024)
+
+                json_median = statistics.median(json_times)
+                msgpack_median = statistics.median(msgpack_times)
+                print(f"\n  JSON/msgpack ratio: {json_median / msgpack_median:.2f}x")
+
+            # Serialization-only benchmark
+            print("\n--- Serialization only (raw dict -> bytes) ---")
+            # Build a representative data dict
+            sample_data: dict = {"project": project, "metrics": {}}
+            for m in range(args.metrics):
+                metric_dict: dict = {}
+                for r in range(args.runs):
+                    metric_dict[f"run_{r}"] = {
+                        "steps": list(range(args.steps)),
+                        "values": [i * 0.1 for i in range(args.steps)],
+                        "timestamps": [1700000000000 + i * 1000 for i in range(args.steps)],
+                    }
+                sample_data["metrics"][f"metric_{m}"] = metric_dict
+
+            ser_results = bench_serialization_only(sample_data, n_iterations=args.iterations)
+            for label, times in ser_results.items():
+                size = len(json.dumps(sample_data).encode()) / 1024 if "json" in label else len(msgpack.packb(sample_data, use_single_float=True)) / 1024
+                print_stats(label, times, size)
+        finally:
+            configure_data_dir(None)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

biome.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "suspicious": {
+        "noExplicitAny": "off"
+      },
+      "style": {
+        "useImportType": "off"
+      }
+    }
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 160
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "semicolons": "always",
+      "trailingCommas": "es5"
+    }
+  },
+  "overrides": [
+    {
+      "include": ["tests/fixtures.js"],
+      "linter": {
+        "rules": {
+          "correctness": {
+            "noEmptyPattern": "off"
+          }
+        }
+      }
+    }
+  ],
+  "files": {
+    "include": ["src/**/*.js", "tests/**/*.js", "*.js"],
+    "ignore": ["node_modules/**", "dist/**", "build/**", "docs/**", "site/**", "site.old/**", "playwright-report/**", ".venv", "coverage/**"]
+  }
+}

examples/generate_random_runs.py

@@ -0,0 +1,228 @@
+"""
+Sample script to generate multiple random experiment runs.
+Creates 4 different runs, each recording 100 steps of metrics.
+"""
+
+import math
+import random
+
+import aspara
+
+
+def generate_metrics_with_trend(
+    step: int,
+    total_steps: int,
+    base_values: dict[str, float],
+    noise_levels: dict[str, float],
+    trends: dict[str, float],
+) -> dict[str, float]:
+    """
+    Generate metrics with trend and noise.
+
+    Args:
+        step: Current step
+        total_steps: Total number of steps
+        base_values: Initial values for each metric
+        noise_levels: Noise level for each metric
+        trends: Final change amount for each metric
+
+    Returns:
+        Generated metrics
+    """
+    progress = step / total_steps
+    metrics = {}
+
+    for metric_name, base_value in base_values.items():
+        # Change due to trend (linear + slight exponential component)
+        trend_factor = progress * (1.0 + 0.2 * math.log(1 + 5 * progress))
+        trend_change = trends[metric_name] * trend_factor
+
+        # Random noise (sine wave + Gaussian noise)
+        noise = (
+            noise_levels[metric_name] * math.sin(step * 0.2) * 0.3  # Periodic noise
+            + noise_levels[metric_name] * random.gauss(0, 0.5)  # Random noise
+        )
+
+        # Calculate final value
+        value = base_value + trend_change + noise
+
+        # Limit value range (accuracy between 0-1, loss >= 0)
+        if "accuracy" in metric_name:
+            value = max(0.0, min(1.0, value))
+        elif "loss" in metric_name:
+            value = max(0.01, value)
+
+        metrics[metric_name] = value
+
+    return metrics
+
+
+def create_run_config(run_id: int) -> tuple[dict[str, float], dict[str, float], dict[str, float]]:
+    """
+    Create configuration for each run.
+
+    Args:
+        run_id: Run number
+
+    Returns:
+        Tuple of (initial values, noise levels, trends)
+    """
+    # Set slightly different initial values for each run
+    base_values = {
+        "accuracy": 0.3 + random.uniform(-0.1, 0.1),
+        "loss": 1.0 + random.uniform(-0.2, 0.2),
+        "val_accuracy": 0.25 + random.uniform(-0.1, 0.1),
+        "val_loss": 1.1 + random.uniform(-0.2, 0.2),
+    }
+
+    # Set noise levels
+    noise_levels = {
+        "accuracy": 0.02 + 0.01 * run_id,
+        "loss": 0.05 + 0.02 * run_id,
+        "val_accuracy": 0.03 + 0.01 * run_id,
+        "val_loss": 0.07 + 0.02 * run_id,
+    }
+
+    # Set trends (accuracy increases, loss decreases)
+    trends = {
+        "accuracy": 0.5 + random.uniform(-0.1, 0.1),  # Upward trend
+        "loss": -0.8 + random.uniform(-0.1, 0.1),  # Downward trend
+        "val_accuracy": 0.45 + random.uniform(-0.1, 0.1),  # Upward trend (slightly lower than train)
+        "val_loss": -0.75 + random.uniform(-0.1, 0.1),  # Downward trend (slightly higher than train)
+    }
+
+    return base_values, noise_levels, trends
+
+
+def generate_run(
+    project: str,
+    run_id: int,
+    total_steps: int = 100,
+    project_tags: list[str] | None = None,
+    run_name: str | None = None,
+) -> None:
+    """
+    Generate an experiment run with the specified ID.
+
+    Args:
+        project: Project name
+        run_id: Run number
+        total_steps: Number of steps to generate
+        project_tags: Common tags for the project
+        run_name: Run name (generated from run_id if not specified)
+    """
+    # Initialize run
+    if run_name is None:
+        run_name = f"random_training_run_{run_id}"
+
+    print(f"Starting generation of run {run_id} for project '{project}'! ({run_name})")
+
+    # Create run configuration
+    base_values, noise_levels, trends = create_run_config(run_id)
+
+    # Add run-specific tags (fruits) to project-common tags (animals)
+    fruits = ["apple", "pear", "orange", "grape", "banana", "mango"]
+    num_fruit_tags = random.randint(1, len(fruits))
+    run_tags = random.sample(fruits, k=num_fruit_tags)
+
+    aspara.init(
+        project=project,
+        name=run_name,
+        config={
+            "learning_rate": 0.01 * (1 + 0.2 * run_id),
+            "batch_size": 32 * (1 + run_id % 2),
+            "optimizer": ["adam", "sgd", "rmsprop", "adagrad"][run_id % 4],
+            "model_type": "mlp",
+            "hidden_layers": [128, 64, 32],
+            "dropout": 0.2 + 0.05 * run_id,
+            "epochs": 10,
+            "run_id": run_id,
+        },
+        tags=run_tags,
+        project_tags=project_tags,
+    )
+
+    # Simulate training loop
+    print(f"Generating metrics for {total_steps} steps...")
+    for step in range(total_steps):
+        # Generate metrics
+        metrics = generate_metrics_with_trend(step, total_steps, base_values, noise_levels, trends)
+
+        # Log metrics
+        aspara.log(metrics, step=step)
+
+        # Show progress (every 10 steps)
+        if step % 10 == 0 or step == total_steps - 1:
+            print(f"  Step {step}/{total_steps - 1}: accuracy={metrics['accuracy']:.3f}, loss={metrics['loss']:.3f}")
+
+    # Finish run
+    aspara.finish()
+
+    print(f"Completed generation of run {run_id} for project '{project}'!")
+
+
+def main() -> None:
+    """Main function: Generate multiple runs."""
+    steps_per_run = 100
+
+    # Cool secret project names
+    project_names = [
+        "Project_Phoenix",
+        "Operation_Midnight",
+        "Genesis_Initiative",
+        "Project_Prometheus",
+    ]
+
+    # Famous SF titles (mix of Western and Japanese works)
+    sf_titles = [
+        "AKIRA",
+        "Ghost_in_the_Shell",
+        "Planetes",
+        "Steins_Gate",
+        "Paprika",
+        "Blade_Runner",
+        "Dune",
+        "Neuromancer",
+        "Foundation",
+        "The_Martian",
+        "Interstellar",
+        "Solaris",
+        "Hyperion",
+        "Snow_Crash",
+        "Contact",
+        "Arrival",
+        "Gravity",
+        "Moon",
+        "Ex_Machina",
+        "Tenet",
+    ]
+
+    print(f"Generating {len(project_names)} projects!")
+    print(f"   Each project has 4-5 runs! ({steps_per_run} steps per run)")
+    animals = ["dog", "cat", "rabbit", "coala", "bear", "goat"]
+
+    # Shuffle SF titles before using
+    shuffled_sf_titles = sf_titles.copy()
+    random.shuffle(shuffled_sf_titles)
+    sf_title_index = 0
+
+    # Generate multiple projects, create 4-5 runs for each project
+    for project_name in project_names:
+        # Project-common tags (animals)
+        num_project_tags = random.randint(1, len(animals))
+        project_tags = random.sample(animals, k=num_project_tags)
+
+        num_runs = random.randint(4, 5)
+        for run_id in range(num_runs):
+            # Use SF title as run name
+            run_name = shuffled_sf_titles[sf_title_index % len(shuffled_sf_titles)]
+            sf_title_index += 1
+            generate_run(project_name, run_id, steps_per_run, project_tags, run_name)
+            print("")  # Insert blank line
+
+    print("All runs have been generated!")
+    print("   Check them out on the dashboard!")
+
+
+if __name__ == "__main__":
+    main()

examples/slow_metrics_writer.py

@@ -0,0 +1,85 @@
+"""
+Simple slow metrics writer for testing SSE real-time updates.
+
+This is a simpler version that's easy to customize.
+
+Usage:
+    # Terminal 1: Start dashboard
+    aspara dashboard
+
+    # Terminal 2: Run this script
+    uv run python examples/slow_metrics_writer.py
+
+    # Terminal 3 (optional): Run again with different run name
+    uv run python examples/slow_metrics_writer.py --run experiment_2
+
+    # Open browser and watch metrics update in real-time!
+"""
+
+import argparse
+import math
+import random
+import time
+from datetime import datetime
+
+from aspara import Run
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Slow metrics writer for SSE testing")
+    parser.add_argument("--project", default="sse_test", help="Project name")
+    parser.add_argument("--run", default="experiment_1", help="Run name")
+    parser.add_argument("--steps", type=int, default=30, help="Number of steps")
+    parser.add_argument("--delay", type=float, default=2.0, help="Delay between steps (seconds)")
+    args = parser.parse_args()
+
+    # Random parameters for this run
+    run_seed = hash(args.run) % 1000
+    random.seed(run_seed)
+
+    loss_base = 1.2 + random.uniform(-0.2, 0.2)
+    acc_base = 0.3 + random.uniform(-0.1, 0.1)
+    noise_level = 0.015 + random.uniform(0, 0.01)
+
+    # Create run
+    run = Run(
+        project=args.project,
+        name=args.run,
+        tags=["sse", "test", "realtime"],
+        notes="Testing SSE real-time updates",
+    )
+
+    print(f"🚀 Writing metrics to {args.project}/{args.run}")
+    print(f"   Steps: {args.steps}, Delay: {args.delay}s")
+    print(f"   Base Loss: {loss_base:.3f}, Base Acc: {acc_base:.3f}")
+    print("   Open http://localhost:3141 to watch in real-time!\n")
+
+    # Write metrics gradually
+    for step in range(args.steps):
+        # Add noise (periodic + random)
+        noise = noise_level * (math.sin(step * 0.4) * 0.5 + random.gauss(0, 0.5))
+
+        # Simulate training metrics with noise
+        loss = max(0.01, (loss_base / (step + 1)) + noise)
+        accuracy = min(0.99, acc_base + (0.6 * (1.0 - 1.0 / (step + 1))) + noise * 0.3)
+
+        run.log(
+            {
+                "loss": loss,
+                "accuracy": accuracy,
+                "step_time": 0.1 + (step * 0.01) + random.uniform(-0.01, 0.01),
+            },
+            step=step,
+        )
+
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        print(f"[{timestamp}] Step {step:3d}/{args.steps} | loss={loss:.4f} acc={accuracy:.4f}")
+
+        time.sleep(args.delay)
+
+    run.finish(exit_code=0)
+    print(f"\n✅ Completed! Total time: {args.steps * args.delay:.1f}s")
+
+
+if __name__ == "__main__":
+    main()

icons.config.json

@@ -0,0 +1,82 @@
+{
+  "icons": [
+    {
+      "name": "stop",
+      "style": "solid",
+      "id": "status-icon-wip",
+      "comment": "Work in progress status"
+    },
+    {
+      "name": "x-mark",
+      "style": "outline",
+      "id": "status-icon-failed",
+      "comment": "Failed status"
+    },
+    {
+      "name": "check",
+      "style": "outline",
+      "id": "status-icon-completed",
+      "comment": "Completed status"
+    },
+    {
+      "name": "pencil-square",
+      "style": "outline",
+      "id": "icon-edit",
+      "comment": "Edit/pencil icon for note editing"
+    },
+    {
+      "name": "arrow-uturn-left",
+      "style": "outline",
+      "id": "icon-reset-zoom",
+      "comment": "Reset zoom for chart controls"
+    },
+    {
+      "name": "arrows-pointing-out",
+      "style": "outline",
+      "id": "icon-fullscreen",
+      "comment": "Full screen/expand for chart controls"
+    },
+    {
+      "name": "arrow-down-tray",
+      "style": "outline",
+      "id": "icon-download",
+      "comment": "Download for chart controls"
+    },
+    {
+      "name": "trash",
+      "style": "outline",
+      "id": "icon-delete",
+      "comment": "Delete/trash icon for delete buttons"
+    },
+    {
+      "name": "chevron-left",
+      "style": "outline",
+      "id": "icon-chevron-left",
+      "comment": "Chevron left for sidebar collapse"
+    },
+    {
+      "name": "chevron-right",
+      "style": "outline",
+      "id": "icon-chevron-right",
+      "comment": "Chevron right for sidebar expand"
+    },
+    {
+      "name": "bars-3",
+      "style": "outline",
+      "id": "icon-menu",
+      "comment": "Hamburger menu icon for settings"
+    },
+    {
+      "name": "exclamation-triangle",
+      "style": "outline",
+      "id": "icon-exclamation-triangle",
+      "comment": "Warning/danger icon for confirm modal and maybe_failed status"
+    },
+    {
+      "name": "information-circle",
+      "style": "outline",
+      "id": "icon-information-circle",
+      "comment": "Info icon for confirm modal"
+    }
+  ]
+}

mkdocs.yml

@@ -0,0 +1,89 @@
+site_name: Aspara User Manual
+site_description: Aspara, blazingly fast metrics tracker for machine learning experiments
+site_author: Aspara Development Group
+copyright: Copyright © 2026 Aspara Development Group
+use_directory_urls: false
+
+theme:
+  name: material
+  language: en
+  logo: aspara-icon.png
+  favicon: aspara-icon.png
+  palette:
+    primary: indigo
+    accent: indigo
+  features:
+    - navigation.tabs
+    - navigation.sections
+    - navigation.top
+    - search.highlight
+    - content.code.copy
+
+extra_css:
+  - aspara-theme.css
+
+plugins:
+  - search
+  - mkdocstrings:
+      handlers:
+        python:
+          paths:
+            - src
+          selection:
+            docstring_style: google
+          rendering:
+            show_source: true
+            show_if_no_docstring: false
+            show_root_heading: false
+            show_root_toc_entry: false
+            heading_level: 2
+            show_signature_annotations: true
+            separate_signature: true
+            merge_init_into_class: false
+            docstring_section_style: "spacy"
+            show_symbol_type_heading: true
+            show_symbol_type_toc: true
+
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.superfences
+  - pymdownx.inlinehilite
+  - admonition
+  - pymdownx.details
+  - pymdownx.tabbed:
+      alternate_style: true
+  - tables
+  - footnotes
+
+nav:
+  - Home: index.md
+  - Getting Started:
+    - Overview: getting-started.md
+  - User Guide:
+    - Overview: user-guide/basics.md
+    - Core Concepts: user-guide/concepts.md
+    - Metadata and Notes: user-guide/metadata.md
+    - Visualizing Results in Dashboard: user-guide/dashboard-visualization.md
+    - Terminal UI: user-guide/terminal-ui.md
+    - Best Practices: user-guide/best-practices.md
+    - Troubleshooting: user-guide/troubleshooting.md
+  - Advanced:
+    - Configuration: advanced/configuration.md
+    - LocalRun vs RemoteRun: advanced/local-vs-remote.md
+    - Storage: advanced/storage.md
+    - Dashboard: advanced/dashboard.md
+    - Tracker API: advanced/tracker-api.md
+    - Read-only Mode: advanced/read-only-mode.md
+  - Examples:
+    - Overview: examples/index.md
+    - PyTorch: examples/pytorch_example.md
+    - TensorFlow / Keras: examples/tensorflow_example.md
+    - scikit-learn: examples/sklearn_example.md
+  - API Reference:
+    - Overview: api/index.md
+    - aspara: api/aspara.md
+    - Run: api/run.md
+    - Dashboard API: api/dashboard.md
+    - Tracker API: api/tracker.md
+  - Contributing: contributing.md

package.json

@@ -0,0 +1,46 @@
+{
+  "name": "aspara",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "test:ci": "vitest run --coverage",
+    "lint": "biome lint",
+    "format": "biome format --write",
+    "check": "biome check --write",
+    "build:icons": "node scripts/build-icons.js",
+    "build:js": "vite build",
+    "build:css": "tailwindcss -i ./src/aspara/dashboard/static/css/input.css -o ./src/aspara/dashboard/static/dist/css/styles.css --minify",
+    "watch:css": "tailwindcss -i ./src/aspara/dashboard/static/css/input.css -o ./src/aspara/dashboard/static/dist/css/styles.css --watch",
+    "build": "pnpm run build:icons && pnpm run build:js && pnpm run build:css"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "Apache-2.0",
+  "packageManager": "pnpm@10.6.3",
+  "dependencies": {
+    "@jcubic/tagger": "^0.6.2",
+    "@msgpack/msgpack": "^3.1.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@playwright/test": "^1.58.2",
+    "@swc/core": "^1.15.17",
+    "@tailwindcss/cli": "^4.2.1",
+    "@testing-library/dom": "^10.4.1",
+    "@vitest/coverage-v8": ">=4.1.0",
+    "@vitest/ui": ">=4.1.0",
+    "canvas": "npm:@napi-rs/canvas@^0.1.95",
+    "happy-dom": "^20.8.9",
+    "heroicons": "^2.2.0",
+    "jsdom": "^26.1.0",
+    "tailwindcss": "^4.2.1",
+    "vite": "^7.3.5",
+    "vitest": ">=4.1.0"
+  }
+}

playwright.config.js

@@ -0,0 +1,68 @@
+// @ts-check
+import { defineConfig, devices } from '@playwright/test';
+
+const BASE_PORT = 6113;
+
+/**
+ * @see https://playwright.dev/docs/test-configuration
+ */
+export default defineConfig({
+  // Target only E2E tests (avoid conflicts with Vitest)
+  testDir: './tests/e2e',
+
+  // Number of parallel workers
+  // 2 workers in CI, unlimited locally
+  workers: process.env.CI ? 2 : undefined,
+
+  // Test execution timeout
+  timeout: 30 * 1000,
+
+  // Test expectations
+  expect: {
+    // Maximum wait time for an element to become visible
+    timeout: 5000,
+  },
+
+  // Take screenshots of failed tests
+  use: {
+    // Base URL
+    baseURL: `http://localhost:${BASE_PORT}`,
+
+    // Take screenshots
+    screenshot: 'only-on-failure',
+
+    // Record traces
+    trace: 'on-first-retry',
+
+    // Allow downloads
+    acceptDownloads: true,
+  },
+
+  // Test report format
+  // 'list' only outputs to the console and does not generate an HTML report
+  reporter: process.env.CI ? 'github' : 'list',
+
+  // Automatically start the server before tests
+  webServer: {
+    command: `uv run aspara dashboard --port ${BASE_PORT}`,
+    port: BASE_PORT,
+    reuseExistingServer: !process.env.CI,
+    timeout: 60 * 1000,
+  },
+
+  // Project settings
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+    {
+      name: 'webkit',
+      use: { ...devices['Desktop Safari'] },
+    },
+  ],
+});

pnpm-lock.yaml

@@ -0,0 +1,2528 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@jcubic/tagger':
+        specifier: ^0.6.2
+        version: 0.6.2
+      '@msgpack/msgpack':
+        specifier: ^3.1.3
+        version: 3.1.3
+    devDependencies:
+      '@biomejs/biome':
+        specifier: ^1.9.4
+        version: 1.9.4
+      '@playwright/test':
+        specifier: ^1.58.2
+        version: 1.58.2
+      '@swc/core':
+        specifier: ^1.15.17
+        version: 1.15.17
+      '@tailwindcss/cli':
+        specifier: ^4.2.1
+        version: 4.2.1
+      '@testing-library/dom':
+        specifier: ^10.4.1
+        version: 10.4.1
+      '@vitest/coverage-v8':
+        specifier: '>=4.1.0'
+        version: 4.1.9(vitest@4.1.9)
+      '@vitest/ui':
+        specifier: '>=4.1.0'
+        version: 4.1.9(vitest@4.1.9)
+      canvas:
+        specifier: npm:@napi-rs/canvas@^0.1.95
+        version: '@napi-rs/canvas@0.1.95'
+      happy-dom:
+        specifier: ^20.8.9
+        version: 20.8.9
+      heroicons:
+        specifier: ^2.2.0
+        version: 2.2.0
+      jsdom:
+        specifier: ^26.1.0
+        version: 26.1.0(@napi-rs/canvas@0.1.95)
+      tailwindcss:
+        specifier: ^4.2.1
+        version: 4.2.1
+      vite:
+        specifier: ^7.3.5
+        version: 7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1)
+      vitest:
+        specifier: '>=4.1.0'
+        version: 4.1.9(@types/node@26.0.1)(@vitest/coverage-v8@4.1.9)(@vitest/ui@4.1.9)(happy-dom@20.8.9)(jsdom@26.1.0(@napi-rs/canvas@0.1.95))(vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1))
+
+packages:
+
+  '@asamuzakjp/css-color@3.2.0':
+    resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
+
+  '@babel/code-frame@7.29.0':
+    resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.27.1':
+    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.28.5':
+    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.29.0':
+    resolution: {integrity: sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/runtime@7.28.6':
+    resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.29.0':
+    resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
+    engines: {node: '>=6.9.0'}
+
+  '@bcoe/v8-coverage@1.0.2':
+    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
+    engines: {node: '>=18'}
+
+  '@biomejs/biome@1.9.4':
+    resolution: {integrity: sha512-1rkd7G70+o9KkTn5KLmDYXihGoTaIGO9PIIN2ZB7UJxFrWw04CZHPYiMRjYsaDvVV7hP1dYNRLxSANLaBFGpog==}
+    engines: {node: '>=14.21.3'}
+    hasBin: true
+
+  '@biomejs/cli-darwin-arm64@1.9.4':
+    resolution: {integrity: sha512-bFBsPWrNvkdKrNCYeAp+xo2HecOGPAy9WyNyB/jKnnedgzl4W4Hb9ZMzYNbf8dMCGmUdSavlYHiR01QaYR58cw==}
+    engines: {node: '>=14.21.3'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@biomejs/cli-darwin-x64@1.9.4':
+    resolution: {integrity: sha512-ngYBh/+bEedqkSevPVhLP4QfVPCpb+4BBe2p7Xs32dBgs7rh9nY2AIYUL6BgLw1JVXV8GlpKmb/hNiuIxfPfZg==}
+    engines: {node: '>=14.21.3'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@biomejs/cli-linux-arm64-musl@1.9.4':
+    resolution: {integrity: sha512-v665Ct9WCRjGa8+kTr0CzApU0+XXtRgwmzIf1SeKSGAv+2scAlW6JR5PMFo6FzqqZ64Po79cKODKf3/AAmECqA==}
+    engines: {node: '>=14.21.3'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@biomejs/cli-linux-arm64@1.9.4':
+    resolution: {integrity: sha512-fJIW0+LYujdjUgJJuwesP4EjIBl/N/TcOX3IvIHJQNsAqvV2CHIogsmA94BPG6jZATS4Hi+xv4SkBBQSt1N4/g==}
+    engines: {node: '>=14.21.3'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@biomejs/cli-linux-x64-musl@1.9.4':
+    resolution: {integrity: sha512-gEhi/jSBhZ2m6wjV530Yy8+fNqG8PAinM3oV7CyO+6c3CEh16Eizm21uHVsyVBEB6RIM8JHIl6AGYCv6Q6Q9Tg==}
+    engines: {node: '>=14.21.3'}
+    cpu: [x64]
+    os: [linux]
+
+  '@biomejs/cli-linux-x64@1.9.4':
+    resolution: {integrity: sha512-lRCJv/Vi3Vlwmbd6K+oQ0KhLHMAysN8lXoCI7XeHlxaajk06u7G+UsFSO01NAs5iYuWKmVZjmiOzJ0OJmGsMwg==}
+    engines: {node: '>=14.21.3'}
+    cpu: [x64]
+    os: [linux]
+
+  '@biomejs/cli-win32-arm64@1.9.4':
+    resolution: {integrity: sha512-tlbhLk+WXZmgwoIKwHIHEBZUwxml7bRJgk0X2sPyNR3S93cdRq6XulAZRQJ17FYGGzWne0fgrXBKpl7l4M87Hg==}
+    engines: {node: '>=14.21.3'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@biomejs/cli-win32-x64@1.9.4':
+    resolution: {integrity: sha512-8Y5wMhVIPaWe6jw2H+KlEm4wP/f7EW3810ZLmDlrEEy5KvBsb9ECEfu/kMWD484ijfQ8+nIi0giMgu9g1UAuuA==}
+    engines: {node: '>=14.21.3'}
+    cpu: [x64]
+    os: [win32]
+
+  '@csstools/color-helpers@5.1.0':
+    resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
+    engines: {node: '>=18'}
+
+  '@csstools/css-calc@2.1.4':
+    resolution: {integrity: sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^3.0.5
+      '@csstools/css-tokenizer': ^3.0.4
+
+  '@csstools/css-color-parser@3.1.0':
+    resolution: {integrity: sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^3.0.5
+      '@csstools/css-tokenizer': ^3.0.4
+
+  '@csstools/css-parser-algorithms@3.0.5':
+    resolution: {integrity: sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@csstools/css-tokenizer': ^3.0.4
+
+  '@csstools/css-tokenizer@3.0.4':
+    resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
+    engines: {node: '>=18'}
+
+  '@esbuild/aix-ppc64@0.27.3':
+    resolution: {integrity: sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.27.3':
+    resolution: {integrity: sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.3':
+    resolution: {integrity: sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.3':
+    resolution: {integrity: sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.27.3':
+    resolution: {integrity: sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.3':
+    resolution: {integrity: sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.27.3':
+    resolution: {integrity: sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.3':
+    resolution: {integrity: sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.27.3':
+    resolution: {integrity: sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.3':
+    resolution: {integrity: sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.3':
+    resolution: {integrity: sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.3':
+    resolution: {integrity: sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.3':
+    resolution: {integrity: sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.3':
+    resolution: {integrity: sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.3':
+    resolution: {integrity: sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.3':
+    resolution: {integrity: sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.27.3':
+    resolution: {integrity: sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.27.3':
+    resolution: {integrity: sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.27.3':
+    resolution: {integrity: sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.27.3':
+    resolution: {integrity: sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.27.3':
+    resolution: {integrity: sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.27.3':
+    resolution: {integrity: sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.27.3':
+    resolution: {integrity: sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.27.3':
+    resolution: {integrity: sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.3':
+    resolution: {integrity: sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.3':
+    resolution: {integrity: sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@jcubic/tagger@0.6.2':
+    resolution: {integrity: sha512-Pcs/cx8+GXRUuAyxDLKGE+NutXVOaqixTMZhde40R8gMg+paLzdfO3LmmXZ1IYmkm8Nb3a2RyG2N8ZLxcIR3fg==}
+
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@msgpack/msgpack@3.1.3':
+    resolution: {integrity: sha512-47XIizs9XZXvuJgoaJUIE2lFoID8ugvc0jzSHP+Ptfk8nTbnR8g788wv48N03Kx0UkAv559HWRQ3yzOgzlRNUA==}
+    engines: {node: '>= 18'}
+
+  '@napi-rs/canvas-android-arm64@0.1.95':
+    resolution: {integrity: sha512-SqTh0wsYbetckMXEvHqmR7HKRJujVf1sYv1xdlhkifg6TlCSysz1opa49LlS3+xWuazcQcfRfmhA07HxxxGsAA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [android]
+
+  '@napi-rs/canvas-darwin-arm64@0.1.95':
+    resolution: {integrity: sha512-F7jT0Syu+B9DGBUBcMk3qCRIxAWiDXmvEjamwbYfbZl7asI1pmXZUnCOoIu49Wt0RNooToYfRDxU9omD6t5Xuw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@napi-rs/canvas-darwin-x64@0.1.95':
+    resolution: {integrity: sha512-54eb2Ho15RDjYGXO/harjRznBrAvu+j5nQ85Z4Qd6Qg3slR8/Ja+Yvvy9G4yo7rdX6NR9GPkZeSTf2UcKXwaXw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@napi-rs/canvas-linux-arm-gnueabihf@0.1.95':
+    resolution: {integrity: sha512-hYaLCSLx5bmbnclzQc3ado3PgZ66blJWzjXp0wJmdwpr/kH+Mwhj6vuytJIomgksyJoCdIqIa4N6aiqBGJtJ5Q==}
+    engines: {node: '>= 10'}
+    cpu: [arm]
+    os: [linux]
+
+  '@napi-rs/canvas-linux-arm64-gnu@0.1.95':
+    resolution: {integrity: sha512-J7VipONahKsmScPZsipHVQBqpbZx4favaD8/enWzzlGcjiwycOoymL7f4tNeqdjK0su19bDOUt6mjp9gsPWYlw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@napi-rs/canvas-linux-arm64-musl@0.1.95':
+    resolution: {integrity: sha512-PXy0UT1J/8MPG8UAkWp6Fd51ZtIZINFzIjGH909JjQrtCuJf3X6nanHYdz1A+Wq9o4aoPAw1YEUpFS1lelsVlg==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@napi-rs/canvas-linux-riscv64-gnu@0.1.95':
+    resolution: {integrity: sha512-2IzCkW2RHRdcgF9W5/plHvYFpc6uikyjMb5SxjqmNxfyDFz9/HB89yhi8YQo0SNqrGRI7yBVDec7Pt+uMyRWsg==}
+    engines: {node: '>= 10'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@napi-rs/canvas-linux-x64-gnu@0.1.95':
+    resolution: {integrity: sha512-OV/ol/OtcUr4qDhQg8G7SdViZX8XyQeKpPsVv/j3+7U178FGoU4M+yIocdVo1ih/A8GQ63+LjF4jDoEjaVU8Pw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+
+  '@napi-rs/canvas-linux-x64-musl@0.1.95':
+    resolution: {integrity: sha512-Z5KzqBK/XzPz5+SFHKz7yKqClEQ8pOiEDdgk5SlphBLVNb8JFIJkxhtJKSvnJyHh2rjVgiFmvtJzMF0gNwwKyQ==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+
+  '@napi-rs/canvas-win32-arm64-msvc@0.1.95':
+    resolution: {integrity: sha512-aj0YbRpe8qVJ4OzMsK7NfNQePgcf9zkGFzNZ9mSuaxXzhpLHmlF2GivNdCdNOg8WzA/NxV6IU4c5XkXadUMLeA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@napi-rs/canvas-win32-x64-msvc@0.1.95':
+    resolution: {integrity: sha512-GA8leTTCfdjuHi8reICTIxU0081PhXvl3lzIniLUjeLACx9GubUiyzkwFb+oyeKLS5IAGZFLKnzAf4wm2epRlA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
+  '@napi-rs/canvas@0.1.95':
+    resolution: {integrity: sha512-lkg23ge+rgyhgUwXmlbkPEhuhHq/hUi/gXKH+4I7vO+lJrbNfEYcQdJLIGjKyXLQzgFiiyDAwh5vAe/tITAE+w==}
+    engines: {node: '>= 10'}
+
+  '@parcel/watcher-android-arm64@2.5.6':
+    resolution: {integrity: sha512-YQxSS34tPF/6ZG7r/Ih9xy+kP/WwediEUsqmtf0cuCV5TPPKw/PQHRhueUo6JdeFJaqV3pyjm0GdYjZotbRt/A==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  '@parcel/watcher-darwin-arm64@2.5.6':
+    resolution: {integrity: sha512-Z2ZdrnwyXvvvdtRHLmM4knydIdU9adO3D4n/0cVipF3rRiwP+3/sfzpAwA/qKFL6i1ModaabkU7IbpeMBgiVEA==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@parcel/watcher-darwin-x64@2.5.6':
+    resolution: {integrity: sha512-HgvOf3W9dhithcwOWX9uDZyn1lW9R+7tPZ4sug+NGrGIo4Rk1hAXLEbcH1TQSqxts0NYXXlOWqVpvS1SFS4fRg==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@parcel/watcher-freebsd-x64@2.5.6':
+    resolution: {integrity: sha512-vJVi8yd/qzJxEKHkeemh7w3YAn6RJCtYlE4HPMoVnCpIXEzSrxErBW5SJBgKLbXU3WdIpkjBTeUNtyBVn8TRng==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@parcel/watcher-linux-arm-glibc@2.5.6':
+    resolution: {integrity: sha512-9JiYfB6h6BgV50CCfasfLf/uvOcJskMSwcdH1PHH9rvS1IrNy8zad6IUVPVUfmXr+u+Km9IxcfMLzgdOudz9EQ==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  '@parcel/watcher-linux-arm-musl@2.5.6':
+    resolution: {integrity: sha512-Ve3gUCG57nuUUSyjBq/MAM0CzArtuIOxsBdQ+ftz6ho8n7s1i9E1Nmk/xmP323r2YL0SONs1EuwqBp2u1k5fxg==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  '@parcel/watcher-linux-arm64-glibc@2.5.6':
+    resolution: {integrity: sha512-f2g/DT3NhGPdBmMWYoxixqYr3v/UXcmLOYy16Bx0TM20Tchduwr4EaCbmxh1321TABqPGDpS8D/ggOTaljijOA==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@parcel/watcher-linux-arm64-musl@2.5.6':
+    resolution: {integrity: sha512-qb6naMDGlbCwdhLj6hgoVKJl2odL34z2sqkC7Z6kzir8b5W65WYDpLB6R06KabvZdgoHI/zxke4b3zR0wAbDTA==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@parcel/watcher-linux-x64-glibc@2.5.6':
+    resolution: {integrity: sha512-kbT5wvNQlx7NaGjzPFu8nVIW1rWqV780O7ZtkjuWaPUgpv2NMFpjYERVi0UYj1msZNyCzGlaCWEtzc+exjMGbQ==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@parcel/watcher-linux-x64-musl@2.5.6':
+    resolution: {integrity: sha512-1JRFeC+h7RdXwldHzTsmdtYR/Ku8SylLgTU/reMuqdVD7CtLwf0VR1FqeprZ0eHQkO0vqsbvFLXUmYm/uNKJBg==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@parcel/watcher-win32-arm64@2.5.6':
+    resolution: {integrity: sha512-3ukyebjc6eGlw9yRt678DxVF7rjXatWiHvTXqphZLvo7aC5NdEgFufVwjFfY51ijYEWpXbqF5jtrK275z52D4Q==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@parcel/watcher-win32-ia32@2.5.6':
+    resolution: {integrity: sha512-k35yLp1ZMwwee3Ez/pxBi5cf4AoBKYXj00CZ80jUz5h8prpiaQsiRPKQMxoLstNuqe2vR4RNPEAEcjEFzhEz/g==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@parcel/watcher-win32-x64@2.5.6':
+    resolution: {integrity: sha512-hbQlYcCq5dlAX9Qx+kFb0FHue6vbjlf0FrNzSKdYK2APUf7tGfGxQCk2ihEREmbR6ZMc0MVAD5RIX/41gpUzTw==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  '@parcel/watcher@2.5.6':
+    resolution: {integrity: sha512-tmmZ3lQxAe/k/+rNnXQRawJ4NjxO2hqiOLTHvWchtGZULp4RyFeh6aU4XdOYBFe2KE1oShQTv4AblOs2iOrNnQ==}
+    engines: {node: '>= 10.0.0'}
+
+  '@playwright/test@1.58.2':
+    resolution: {integrity: sha512-akea+6bHYBBfA9uQqSYmlJXn61cTa+jbO87xVLCWbTqbWadRVmhxlXATaOjOgcBaWU4ePo0wB41KMFv3o35IXA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@polka/url@1.0.0-next.29':
+    resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
+
+  '@rollup/rollup-android-arm-eabi@4.59.0':
+    resolution: {integrity: sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.59.0':
+    resolution: {integrity: sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.59.0':
+    resolution: {integrity: sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.59.0':
+    resolution: {integrity: sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.59.0':
+    resolution: {integrity: sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.59.0':
+    resolution: {integrity: sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.59.0':
+    resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.59.0':
+    resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-gnu@4.59.0':
+    resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-musl@4.59.0':
+    resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loong64-gnu@4.59.0':
+    resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loong64-musl@4.59.0':
+    resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-ppc64-gnu@4.59.0':
+    resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-ppc64-musl@4.59.0':
+    resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.59.0':
+    resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-musl@4.59.0':
+    resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-s390x-gnu@4.59.0':
+    resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-gnu@4.59.0':
+    resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-musl@4.59.0':
+    resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-openbsd-x64@4.59.0':
+    resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@rollup/rollup-openharmony-arm64@4.59.0':
+    resolution: {integrity: sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.59.0':
+    resolution: {integrity: sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.59.0':
+    resolution: {integrity: sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-gnu@4.59.0':
+    resolution: {integrity: sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.59.0':
+    resolution: {integrity: sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@swc/core-darwin-arm64@1.15.17':
+    resolution: {integrity: sha512-eB9qdyt4E60323IS0rgV/rd79DJ+YWSyIKi+sT1dlIgR3ns4xlBiunREM3lVH0FKcUbhttiBvdVubT4QoOuZ+w==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@swc/core-darwin-x64@1.15.17':
+    resolution: {integrity: sha512-k1TZARYs8947jJpSioqcPrusz+wEeABF4iiSdwcSyQh2rIUdIEk5FOyaqJASFPJ6dZfx7ZVOyjtDATVAegs2/Q==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@swc/core-linux-arm-gnueabihf@1.15.17':
+    resolution: {integrity: sha512-p6282NQZo5bzx0wphz1ETGjhcRB9CN+/XUAjQwApyoyX9iCloI5IT/RC3vjbflo42g8RPTxUTaItAO0hlLSesQ==}
+    engines: {node: '>=10'}
+    cpu: [arm]
+    os: [linux]
+
+  '@swc/core-linux-arm64-gnu@1.15.17':
+    resolution: {integrity: sha512-TGnDS4ejy8y9jqxXqZCyA+DvFc64nXUHS9rxdyeJ9B9uyIdtKVhBrA2xfghYRS/sSPSyHZ0yu89NxBICvONH+A==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@swc/core-linux-arm64-musl@1.15.17':
+    resolution: {integrity: sha512-D0/6Hj4CkgSTTahtlGxv9IDsLTuvQz30mkZEMDp8TqwYhCL8AomznkibwlQU8HtY4q/dqd1OGRPH+FmNb4BBEA==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@swc/core-linux-x64-gnu@1.15.17':
+    resolution: {integrity: sha512-1s2OFsg6DeRkWU7c+PIfIHZsFCbiZ34akXFHrg7KjpF8zIvpHZNoUUZimoWEwcB6GquXSkAO+1b5KpG5nusTeQ==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [linux]
+
+  '@swc/core-linux-x64-musl@1.15.17':
+    resolution: {integrity: sha512-gtxGMGYtRWWmCcgx6xM2Yos43uiE/j8kZwkeL/LNGG9zM0tatd23NsfL9PnQJ45hY7QZ+dx2rM68e4ArgG4kJg==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [linux]
+
+  '@swc/core-win32-arm64-msvc@1.15.17':
+    resolution: {integrity: sha512-gxi+/Miytez/O9vJ/QiheIivA3oWZjPp9nJu3VmAfLMWUzcZORMwgaI1ygtDTLjz7CzcwlGMJz/Ab66Y5DfNpg==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@swc/core-win32-ia32-msvc@1.15.17':
+    resolution: {integrity: sha512-KUsRqNbTp7SpNK0T9m4+i8GlngzNjwb69a3ttKA6XJ5r6Pewm+NSYji93pNkawXIivbWY2jhvceGMAyd+4hWaQ==}
+    engines: {node: '>=10'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@swc/core-win32-x64-msvc@1.15.17':
+    resolution: {integrity: sha512-zqtEGE0/rTKvEC5sOtpANLHeWEPjsTD4/rwpUxo6ymztcLI/Z+L9Wi9xQvIGmLTUih1gvNZcAwROqdfRP3oAWQ==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [win32]
+
+  '@swc/core@1.15.17':
+    resolution: {integrity: sha512-Mu3eOrYlkdQPl7yqotNckitTr6FZ0yd7mlWIBEzK+EGIyybgMENJHmbS2DeA7BMleJiBElP6ke+Nz93pkKmKJw==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@swc/helpers': '>=0.5.17'
+    peerDependenciesMeta:
+      '@swc/helpers':
+        optional: true
+
+  '@swc/counter@0.1.3':
+    resolution: {integrity: sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==}
+
+  '@swc/types@0.1.25':
+    resolution: {integrity: sha512-iAoY/qRhNH8a/hBvm3zKj9qQ4oc2+3w1unPJa2XvTK3XjeLXtzcCingVPw/9e5mn1+0yPqxcBGp9Jf0pkfMb1g==}
+
+  '@tailwindcss/cli@4.2.1':
+    resolution: {integrity: sha512-b7MGn51IA80oSG+7fuAgzfQ+7pZBgjzbqwmiv6NO7/+a1sev32cGqnwhscT7h0EcAvMa9r7gjRylqOH8Xhc4DA==}
+    hasBin: true
+
+  '@tailwindcss/node@4.2.1':
+    resolution: {integrity: sha512-jlx6sLk4EOwO6hHe1oCGm1Q4AN/s0rSrTTPBGPM0/RQ6Uylwq17FuU8IeJJKEjtc6K6O07zsvP+gDO6MMWo7pg==}
+
+  '@tailwindcss/oxide-android-arm64@4.2.1':
+    resolution: {integrity: sha512-eZ7G1Zm5EC8OOKaesIKuw77jw++QJ2lL9N+dDpdQiAB/c/B2wDh0QPFHbkBVrXnwNugvrbJFk1gK2SsVjwWReg==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [android]
+
+  '@tailwindcss/oxide-darwin-arm64@4.2.1':
+    resolution: {integrity: sha512-q/LHkOstoJ7pI1J0q6djesLzRvQSIfEto148ppAd+BVQK0JYjQIFSK3JgYZJa+Yzi0DDa52ZsQx2rqytBnf8Hw==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-darwin-x64@4.2.1':
+    resolution: {integrity: sha512-/f/ozlaXGY6QLbpvd/kFTro2l18f7dHKpB+ieXz+Cijl4Mt9AI2rTrpq7V+t04nK+j9XBQHnSMdeQRhbGyt6fw==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-freebsd-x64@4.2.1':
+    resolution: {integrity: sha512-5e/AkgYJT/cpbkys/OU2Ei2jdETCLlifwm7ogMC7/hksI2fC3iiq6OcXwjibcIjPung0kRtR3TxEITkqgn0TcA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.1':
+    resolution: {integrity: sha512-Uny1EcVTTmerCKt/1ZuKTkb0x8ZaiuYucg2/kImO5A5Y/kBz41/+j0gxUZl+hTF3xkWpDmHX+TaWhOtba2Fyuw==}
+    engines: {node: '>= 20'}
+    cpu: [arm]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.2.1':
+    resolution: {integrity: sha512-CTrwomI+c7n6aSSQlsPL0roRiNMDQ/YzMD9EjcR+H4f0I1SQ8QqIuPnsVp7QgMkC1Qi8rtkekLkOFjo7OlEFRQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.2.1':
+    resolution: {integrity: sha512-WZA0CHRL/SP1TRbA5mp9htsppSEkWuQ4KsSUumYQnyl8ZdT39ntwqmz4IUHGN6p4XdSlYfJwM4rRzZLShHsGAQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.2.1':
+    resolution: {integrity: sha512-qMFzxI2YlBOLW5PhblzuSWlWfwLHaneBE0xHzLrBgNtqN6mWfs+qYbhryGSXQjFYB1Dzf5w+LN5qbUTPhW7Y5g==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-x64-musl@4.2.1':
+    resolution: {integrity: sha512-5r1X2FKnCMUPlXTWRYpHdPYUY6a1Ar/t7P24OuiEdEOmms5lyqjDRvVY1yy9Rmioh+AunQ0rWiOTPE8F9A3v5g==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+
+  '@tailwindcss/oxide-wasm32-wasi@4.2.1':
+    resolution: {integrity: sha512-MGFB5cVPvshR85MTJkEvqDUnuNoysrsRxd6vnk1Lf2tbiqNlXpHYZqkqOQalydienEWOHHFyyuTSYRsLfxFJ2Q==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+    bundledDependencies:
+      - '@napi-rs/wasm-runtime'
+      - '@emnapi/core'
+      - '@emnapi/runtime'
+      - '@tybys/wasm-util'
+      - '@emnapi/wasi-threads'
+      - tslib
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.2.1':
+    resolution: {integrity: sha512-YlUEHRHBGnCMh4Nj4GnqQyBtsshUPdiNroZj8VPkvTZSoHsilRCwXcVKnG9kyi0ZFAS/3u+qKHBdDc81SADTRA==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.2.1':
+    resolution: {integrity: sha512-rbO34G5sMWWyrN/idLeVxAZgAKWrn5LiR3/I90Q9MkA67s6T1oB0xtTe+0heoBvHSpbU9Mk7i6uwJnpo4u21XQ==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [win32]
+
+  '@tailwindcss/oxide@4.2.1':
+    resolution: {integrity: sha512-yv9jeEFWnjKCI6/T3Oq50yQEOqmpmpfzG1hcZsAOaXFQPfzWprWrlHSdGPEF3WQTi8zu8ohC9Mh9J470nT5pUw==}
+    engines: {node: '>= 20'}
+
+  '@testing-library/dom@10.4.1':
+    resolution: {integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==}
+    engines: {node: '>=18'}
+
+  '@types/aria-query@5.0.4':
+    resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==}
+
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
+  '@types/deep-eql@4.0.2':
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/node@26.0.1':
+    resolution: {integrity: sha512-fc3KiUoBt6kie0N9bIW3E47vZsuaMf0PM2AaUpLCLT0s/LvX1nxAim6Fc049cNxODPpGm6qRAuUOB86SkRuPQw==}
+
+  '@types/whatwg-mimetype@3.0.2':
+    resolution: {integrity: sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA==}
+
+  '@types/ws@8.18.1':
+    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
+
+  '@vitest/coverage-v8@4.1.9':
+    resolution: {integrity: sha512-G9/lgqibheLVBDRuya45EbsEXTYcWoSG+TLg7i2axuzx0Eq62eXn+aWXyaVdV5vKvFSWd6ywcX8hA7la9Pvu8g==}
+    peerDependencies:
+      '@vitest/browser': 4.1.9
+      vitest: 4.1.9
+    peerDependenciesMeta:
+      '@vitest/browser':
+        optional: true
+
+  '@vitest/expect@4.1.9':
+    resolution: {integrity: sha512-vl/rYsUKcBr3SnQn166+XR5ZQcgMx3DQhFWdfli/cWpLnLUmbxZvyrJZotLFUryib+LtArYMSTJ5RbQ57ZqrlA==}
+
+  '@vitest/mocker@4.1.9':
+    resolution: {integrity: sha512-EVkXzBjrPGM+cK8/ANWgBrkUCfJfb38/EfTSO8h7pWvKkyPkpWxvR7BkD2MyItMF62C97zAEoqdpUixwR/e+Rw==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/pretty-format@4.1.9':
+    resolution: {integrity: sha512-s0iufns3iIFitdgm+YR7g1whCAaGtXz459VS9/PqyKDEEFgYIhsHOQmXgIgDuYCt7DeQmiZT0Qe2OA2p4ZPu5A==}
+
+  '@vitest/runner@4.1.9':
+    resolution: {integrity: sha512-KXLMDtc7oe70+3mJfGrPUWPesswH+3sTxAMAMl8DG7I8IUQT4XW718dY5ID3vPUcmlu27CcKfY4P3h3I29SLJg==}
+
+  '@vitest/snapshot@4.1.9':
+    resolution: {integrity: sha512-Jc7RKGNBo8Z28WYIm0Niej4xdSPByRf6mU58VpHQkd6Zh05rlnA+twjbK5HyeIGHxrzsc3mJgS43uM0CZKzaIA==}
+
+  '@vitest/spy@4.1.9':
+    resolution: {integrity: sha512-fHpsS6mIi+PiEW+vcRVOMkX1oSaPKne3VOclSFICPcGOmfKgXPU5iAah+wcNcj2xPrCCmfq99IDGf+EojhhvhA==}
+
+  '@vitest/ui@4.1.9':
+    resolution: {integrity: sha512-U/cRvtqfEPj27FI1n9cyUvi4vXXdcLhjJiI+InYKdk8hP4VrS6RXOjGL7rfFaeBc37iRKANsR6eEzIoC7lmgBQ==}
+    peerDependencies:
+      vitest: 4.1.9
+
+  '@vitest/utils@4.1.9':
+    resolution: {integrity: sha512-A51o8ymO5PpqlWNnBP9ZHPXDIpuMtTLlGSjN7la4US+LJzoUMyhwjA5QXlm39JexgwHKW4Xjs8Z2d3dLCXOeuA==}
+
+  agent-base@7.1.4:
+    resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
+    engines: {node: '>= 14'}
+
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  ansi-styles@5.2.0:
+    resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}
+    engines: {node: '>=10'}
+
+  aria-query@5.3.0:
+    resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==}
+
+  assertion-error@2.0.1:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
+  ast-v8-to-istanbul@1.0.4:
+    resolution: {integrity: sha512-0bC0/4bTSrnwdhU3IsZDwEdojvuPrSg59OYZfKsLRtJZ0u8VBx9DebfqqG8bRdCC0I7vjgxmPi41P0lpkhJHtA==}
+
+  chai@6.2.2:
+    resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+    engines: {node: '>=18'}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  cssstyle@4.6.0:
+    resolution: {integrity: sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==}
+    engines: {node: '>=18'}
+
+  data-urls@5.0.0:
+    resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==}
+    engines: {node: '>=18'}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decimal.js@10.6.0:
+    resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
+
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+
+  dom-accessibility-api@0.5.16:
+    resolution: {integrity: sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==}
+
+  enhanced-resolve@5.20.0:
+    resolution: {integrity: sha512-/ce7+jQ1PQ6rVXwe+jKEg5hW5ciicHwIQUagZkp6IufBoY3YDgdTTY1azVs0qoRgVmvsNB+rbjLJxDAeHHtwsQ==}
+    engines: {node: '>=10.13.0'}
+
+  entities@6.0.1:
+    resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
+    engines: {node: '>=0.12'}
+
+  entities@7.0.1:
+    resolution: {integrity: sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==}
+    engines: {node: '>=0.12'}
+
+  es-module-lexer@2.1.0:
+    resolution: {integrity: sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==}
+
+  esbuild@0.27.3:
+    resolution: {integrity: sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  expect-type@1.3.0:
+    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
+    engines: {node: '>=12.0.0'}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  fflate@0.8.2:
+    resolution: {integrity: sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==}
+
+  flatted@3.4.2:
+    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
+
+  fsevents@2.3.2:
+    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  happy-dom@20.8.9:
+    resolution: {integrity: sha512-Tz23LR9T9jOGVZm2x1EPdXqwA37G/owYMxRwU0E4miurAtFsPMQ1d2Jc2okUaSjZqAFz2oEn3FLXC5a0a+siyA==}
+    engines: {node: '>=20.0.0'}
+
+  has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+
+  heroicons@2.2.0:
+    resolution: {integrity: sha512-yOwvztmNiBWqR946t+JdgZmyzEmnRMC2nxvHFC90bF1SUttwB6yJKYeme1JeEcBfobdOs827nCyiWBS2z/brog==}
+
+  html-encoding-sniffer@4.0.0:
+    resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
+    engines: {node: '>=18'}
+
+  html-escaper@2.0.2:
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
+
+  http-proxy-agent@7.0.2:
+    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
+    engines: {node: '>= 14'}
+
+  https-proxy-agent@7.0.6:
+    resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
+    engines: {node: '>= 14'}
+
+  iconv-lite@0.6.3:
+    resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
+    engines: {node: '>=0.10.0'}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-potential-custom-element-name@1.0.1:
+    resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
+
+  istanbul-lib-coverage@3.2.2:
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
+
+  istanbul-lib-report@3.0.1:
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
+
+  istanbul-reports@3.2.0:
+    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
+    engines: {node: '>=8'}
+
+  jiti@2.6.1:
+    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
+    hasBin: true
+
+  js-tokens@10.0.0:
+    resolution: {integrity: sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  jsdom@26.1.0:
+    resolution: {integrity: sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      canvas: ^3.0.0
+    peerDependenciesMeta:
+      canvas:
+        optional: true
+
+  lightningcss-android-arm64@1.31.1:
+    resolution: {integrity: sha512-HXJF3x8w9nQ4jbXRiNppBCqeZPIAfUo8zE/kOEGbW5NZvGc/K7nMxbhIr+YlFlHW5mpbg/YFPdbnCh1wAXCKFg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  lightningcss-darwin-arm64@1.31.1:
+    resolution: {integrity: sha512-02uTEqf3vIfNMq3h/z2cJfcOXnQ0GRwQrkmPafhueLb2h7mqEidiCzkE4gBMEH65abHRiQvhdcQ+aP0D0g67sg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  lightningcss-darwin-x64@1.31.1:
+    resolution: {integrity: sha512-1ObhyoCY+tGxtsz1lSx5NXCj3nirk0Y0kB/g8B8DT+sSx4G9djitg9ejFnjb3gJNWo7qXH4DIy2SUHvpoFwfTA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  lightningcss-freebsd-x64@1.31.1:
+    resolution: {integrity: sha512-1RINmQKAItO6ISxYgPwszQE1BrsVU5aB45ho6O42mu96UiZBxEXsuQ7cJW4zs4CEodPUioj/QrXW1r9pLUM74A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  lightningcss-linux-arm-gnueabihf@1.31.1:
+    resolution: {integrity: sha512-OOCm2//MZJ87CdDK62rZIu+aw9gBv4azMJuA8/KB74wmfS3lnC4yoPHm0uXZ/dvNNHmnZnB8XLAZzObeG0nS1g==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  lightningcss-linux-arm64-gnu@1.31.1:
+    resolution: {integrity: sha512-WKyLWztD71rTnou4xAD5kQT+982wvca7E6QoLpoawZ1gP9JM0GJj4Tp5jMUh9B3AitHbRZ2/H3W5xQmdEOUlLg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  lightningcss-linux-arm64-musl@1.31.1:
+    resolution: {integrity: sha512-mVZ7Pg2zIbe3XlNbZJdjs86YViQFoJSpc41CbVmKBPiGmC4YrfeOyz65ms2qpAobVd7WQsbW4PdsSJEMymyIMg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  lightningcss-linux-x64-gnu@1.31.1:
+    resolution: {integrity: sha512-xGlFWRMl+0KvUhgySdIaReQdB4FNudfUTARn7q0hh/V67PVGCs3ADFjw+6++kG1RNd0zdGRlEKa+T13/tQjPMA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  lightningcss-linux-x64-musl@1.31.1:
+    resolution: {integrity: sha512-eowF8PrKHw9LpoZii5tdZwnBcYDxRw2rRCyvAXLi34iyeYfqCQNA9rmUM0ce62NlPhCvof1+9ivRaTY6pSKDaA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  lightningcss-win32-arm64-msvc@1.31.1:
+    resolution: {integrity: sha512-aJReEbSEQzx1uBlQizAOBSjcmr9dCdL3XuC/6HLXAxmtErsj2ICo5yYggg1qOODQMtnjNQv2UHb9NpOuFtYe4w==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  lightningcss-win32-x64-msvc@1.31.1:
+    resolution: {integrity: sha512-I9aiFrbd7oYHwlnQDqr1Roz+fTz61oDDJX7n9tYF9FJymH1cIN1DtKw3iYt6b8WZgEjoNwVSncwF4wx/ZedMhw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  lightningcss@1.31.1:
+    resolution: {integrity: sha512-l51N2r93WmGUye3WuFoN5k10zyvrVs0qfKBhyC5ogUQ6Ew6JUSswh78mbSO+IU3nTWsyOArqPCcShdQSadghBQ==}
+    engines: {node: '>= 12.0.0'}
+
+  lru-cache@10.4.3:
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
+
+  lz-string@1.5.0:
+    resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==}
+    hasBin: true
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  magicast@0.5.2:
+    resolution: {integrity: sha512-E3ZJh4J3S9KfwdjZhe2afj6R9lGIN5Pher1pF39UGrXRqq/VDaGVIGN13BjHd2u8B61hArAGOnso7nBOouW3TQ==}
+
+  make-dir@4.0.0:
+    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
+    engines: {node: '>=10'}
+
+  mri@1.2.0:
+    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
+    engines: {node: '>=4'}
+
+  mrmime@2.0.1:
+    resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
+    engines: {node: '>=10'}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  nanoid@3.3.11:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  node-addon-api@7.1.1:
+    resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
+
+  nwsapi@2.2.23:
+    resolution: {integrity: sha512-7wfH4sLbt4M0gCDzGE6vzQBo0bfTKjU7Sfpqy/7gs1qBfYz2vEJH6vXcBKpO3+6Yu1telwd0t9HpyOoLEQQbIQ==}
+
+  obug@2.1.1:
+    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
+
+  parse5@7.3.0:
+    resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
+
+  pathe@2.0.3:
+    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  playwright-core@1.58.2:
+    resolution: {integrity: sha512-yZkEtftgwS8CsfYo7nm0KE8jsvm6i/PTgVtB8DL726wNf6H2IMsDuxCpJj59KDaxCtSnrWan2AeDqM7JBaultg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  playwright@1.58.2:
+    resolution: {integrity: sha512-vA30H8Nvkq/cPBnNw4Q8TWz1EJyqgpuinBcHET0YVJVFldr8JDNiU9LaWAE1KqSkRYazuaBhTpB5ZzShOezQ6A==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  pretty-format@27.5.1:
+    resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==}
+    engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0}
+
+  punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  react-is@17.0.2:
+    resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==}
+
+  rollup@4.59.0:
+    resolution: {integrity: sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  rrweb-cssom@0.8.0:
+    resolution: {integrity: sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  saxes@6.0.0:
+    resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
+    engines: {node: '>=v12.22.7'}
+
+  semver@7.7.4:
+    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  siginfo@2.0.0:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
+  sirv@3.0.2:
+    resolution: {integrity: sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==}
+    engines: {node: '>=18'}
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  stackback@0.0.2:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+  std-env@4.1.0:
+    resolution: {integrity: sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==}
+
+  supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+
+  symbol-tree@3.2.4:
+    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
+
+  tailwindcss@4.2.1:
+    resolution: {integrity: sha512-/tBrSQ36vCleJkAOsy9kbNTgaxvGbyOamC30PRePTQe/o1MFwEKHQk4Cn7BNGaPtjp+PuUrByJehM1hgxfq4sw==}
+
+  tapable@2.3.0:
+    resolution: {integrity: sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==}
+    engines: {node: '>=6'}
+
+  tinybench@2.9.0:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+  tinyexec@1.0.2:
+    resolution: {integrity: sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==}
+    engines: {node: '>=18'}
+
+  tinyglobby@0.2.15:
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
+    engines: {node: '>=12.0.0'}
+
+  tinyrainbow@3.1.0:
+    resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
+    engines: {node: '>=14.0.0'}
+
+  tldts-core@6.1.86:
+    resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==}
+
+  tldts@6.1.86:
+    resolution: {integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==}
+    hasBin: true
+
+  totalist@3.0.1:
+    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
+    engines: {node: '>=6'}
+
+  tough-cookie@5.1.2:
+    resolution: {integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==}
+    engines: {node: '>=16'}
+
+  tr46@5.1.1:
+    resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}
+    engines: {node: '>=18'}
+
+  undici-types@8.3.0:
+    resolution: {integrity: sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==}
+
+  vite@7.3.6:
+    resolution: {integrity: sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      lightningcss: ^1.21.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  vitest@4.1.9:
+    resolution: {integrity: sha512-nE3/LEyc0z87uHYLZebqCUOaJr2hdtuPp7BQ4BosVFnfltxgAvMG08NyrSGlPpOUWvR27c5flSmYFTNr78L9GQ==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@opentelemetry/api': ^1.9.0
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.1.9
+      '@vitest/browser-preview': 4.1.9
+      '@vitest/browser-webdriverio': 4.1.9
+      '@vitest/coverage-istanbul': 4.1.9
+      '@vitest/coverage-v8': 4.1.9
+      '@vitest/ui': 4.1.9
+      happy-dom: '*'
+      jsdom: '*'
+      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
+        optional: true
+      '@vitest/coverage-istanbul':
+        optional: true
+      '@vitest/coverage-v8':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  w3c-xmlserializer@5.0.0:
+    resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==}
+    engines: {node: '>=18'}
+
+  webidl-conversions@7.0.0:
+    resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
+    engines: {node: '>=12'}
+
+  whatwg-encoding@3.1.1:
+    resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==}
+    engines: {node: '>=18'}
+    deprecated: Use @exodus/bytes instead for a more spec-conformant and faster implementation
+
+  whatwg-mimetype@3.0.0:
+    resolution: {integrity: sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==}
+    engines: {node: '>=12'}
+
+  whatwg-mimetype@4.0.0:
+    resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==}
+    engines: {node: '>=18'}
+
+  whatwg-url@14.2.0:
+    resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
+    engines: {node: '>=18'}
+
+  why-is-node-running@2.3.0:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  ws@8.19.0:
+    resolution: {integrity: sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  ws@8.21.0:
+    resolution: {integrity: sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  xml-name-validator@5.0.0:
+    resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
+    engines: {node: '>=18'}
+
+  xmlchars@2.2.0:
+    resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
+
+snapshots:
+
+  '@asamuzakjp/css-color@3.2.0':
+    dependencies:
+      '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-color-parser': 3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-tokenizer': 3.0.4
+      lru-cache: 10.4.3
+
+  '@babel/code-frame@7.29.0':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.28.5
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/helper-string-parser@7.27.1': {}
+
+  '@babel/helper-validator-identifier@7.28.5': {}
+
+  '@babel/parser@7.29.0':
+    dependencies:
+      '@babel/types': 7.29.0
+
+  '@babel/runtime@7.28.6': {}
+
+  '@babel/types@7.29.0':
+    dependencies:
+      '@babel/helper-string-parser': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
+
+  '@bcoe/v8-coverage@1.0.2': {}
+
+  '@biomejs/biome@1.9.4':
+    optionalDependencies:
+      '@biomejs/cli-darwin-arm64': 1.9.4
+      '@biomejs/cli-darwin-x64': 1.9.4
+      '@biomejs/cli-linux-arm64': 1.9.4
+      '@biomejs/cli-linux-arm64-musl': 1.9.4
+      '@biomejs/cli-linux-x64': 1.9.4
+      '@biomejs/cli-linux-x64-musl': 1.9.4
+      '@biomejs/cli-win32-arm64': 1.9.4
+      '@biomejs/cli-win32-x64': 1.9.4
+
+  '@biomejs/cli-darwin-arm64@1.9.4':
+    optional: true
+
+  '@biomejs/cli-darwin-x64@1.9.4':
+    optional: true
+
+  '@biomejs/cli-linux-arm64-musl@1.9.4':
+    optional: true
+
+  '@biomejs/cli-linux-arm64@1.9.4':
+    optional: true
+
+  '@biomejs/cli-linux-x64-musl@1.9.4':
+    optional: true
+
+  '@biomejs/cli-linux-x64@1.9.4':
+    optional: true
+
+  '@biomejs/cli-win32-arm64@1.9.4':
+    optional: true
+
+  '@biomejs/cli-win32-x64@1.9.4':
+    optional: true
+
+  '@csstools/color-helpers@5.1.0': {}
+
+  '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
+    dependencies:
+      '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-tokenizer': 3.0.4
+
+  '@csstools/css-color-parser@3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
+    dependencies:
+      '@csstools/color-helpers': 5.1.0
+      '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
+      '@csstools/css-tokenizer': 3.0.4
+
+  '@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4)':
+    dependencies:
+      '@csstools/css-tokenizer': 3.0.4
+
+  '@csstools/css-tokenizer@3.0.4': {}
+
+  '@esbuild/aix-ppc64@0.27.3':
+    optional: true
+
+  '@esbuild/android-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/android-arm@0.27.3':
+    optional: true
+
+  '@esbuild/android-x64@0.27.3':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/darwin-x64@0.27.3':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.27.3':
+    optional: true
+
+  '@esbuild/linux-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/linux-arm@0.27.3':
+    optional: true
+
+  '@esbuild/linux-ia32@0.27.3':
+    optional: true
+
+  '@esbuild/linux-loong64@0.27.3':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.27.3':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.27.3':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.27.3':
+    optional: true
+
+  '@esbuild/linux-s390x@0.27.3':
+    optional: true
+
+  '@esbuild/linux-x64@0.27.3':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.27.3':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.27.3':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/sunos-x64@0.27.3':
+    optional: true
+
+  '@esbuild/win32-arm64@0.27.3':
+    optional: true
+
+  '@esbuild/win32-ia32@0.27.3':
+    optional: true
+
+  '@esbuild/win32-x64@0.27.3':
+    optional: true
+
+  '@jcubic/tagger@0.6.2': {}
+
+  '@jridgewell/gen-mapping@0.3.13':
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@msgpack/msgpack@3.1.3': {}
+
+  '@napi-rs/canvas-android-arm64@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-darwin-arm64@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-darwin-x64@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-linux-arm-gnueabihf@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-linux-arm64-gnu@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-linux-arm64-musl@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-linux-riscv64-gnu@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-linux-x64-gnu@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-linux-x64-musl@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-win32-arm64-msvc@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas-win32-x64-msvc@0.1.95':
+    optional: true
+
+  '@napi-rs/canvas@0.1.95':
+    optionalDependencies:
+      '@napi-rs/canvas-android-arm64': 0.1.95
+      '@napi-rs/canvas-darwin-arm64': 0.1.95
+      '@napi-rs/canvas-darwin-x64': 0.1.95
+      '@napi-rs/canvas-linux-arm-gnueabihf': 0.1.95
+      '@napi-rs/canvas-linux-arm64-gnu': 0.1.95
+      '@napi-rs/canvas-linux-arm64-musl': 0.1.95
+      '@napi-rs/canvas-linux-riscv64-gnu': 0.1.95
+      '@napi-rs/canvas-linux-x64-gnu': 0.1.95
+      '@napi-rs/canvas-linux-x64-musl': 0.1.95
+      '@napi-rs/canvas-win32-arm64-msvc': 0.1.95
+      '@napi-rs/canvas-win32-x64-msvc': 0.1.95
+
+  '@parcel/watcher-android-arm64@2.5.6':
+    optional: true
+
+  '@parcel/watcher-darwin-arm64@2.5.6':
+    optional: true
+
+  '@parcel/watcher-darwin-x64@2.5.6':
+    optional: true
+
+  '@parcel/watcher-freebsd-x64@2.5.6':
+    optional: true
+
+  '@parcel/watcher-linux-arm-glibc@2.5.6':
+    optional: true
+
+  '@parcel/watcher-linux-arm-musl@2.5.6':
+    optional: true
+
+  '@parcel/watcher-linux-arm64-glibc@2.5.6':
+    optional: true
+
+  '@parcel/watcher-linux-arm64-musl@2.5.6':
+    optional: true
+
+  '@parcel/watcher-linux-x64-glibc@2.5.6':
+    optional: true
+
+  '@parcel/watcher-linux-x64-musl@2.5.6':
+    optional: true
+
+  '@parcel/watcher-win32-arm64@2.5.6':
+    optional: true
+
+  '@parcel/watcher-win32-ia32@2.5.6':
+    optional: true
+
+  '@parcel/watcher-win32-x64@2.5.6':
+    optional: true
+
+  '@parcel/watcher@2.5.6':
+    dependencies:
+      detect-libc: 2.1.2
+      is-glob: 4.0.3
+      node-addon-api: 7.1.1
+      picomatch: 4.0.3
+    optionalDependencies:
+      '@parcel/watcher-android-arm64': 2.5.6
+      '@parcel/watcher-darwin-arm64': 2.5.6
+      '@parcel/watcher-darwin-x64': 2.5.6
+      '@parcel/watcher-freebsd-x64': 2.5.6
+      '@parcel/watcher-linux-arm-glibc': 2.5.6
+      '@parcel/watcher-linux-arm-musl': 2.5.6
+      '@parcel/watcher-linux-arm64-glibc': 2.5.6
+      '@parcel/watcher-linux-arm64-musl': 2.5.6
+      '@parcel/watcher-linux-x64-glibc': 2.5.6
+      '@parcel/watcher-linux-x64-musl': 2.5.6
+      '@parcel/watcher-win32-arm64': 2.5.6
+      '@parcel/watcher-win32-ia32': 2.5.6
+      '@parcel/watcher-win32-x64': 2.5.6
+
+  '@playwright/test@1.58.2':
+    dependencies:
+      playwright: 1.58.2
+
+  '@polka/url@1.0.0-next.29': {}
+
+  '@rollup/rollup-android-arm-eabi@4.59.0':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-musl@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-musl@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-musl@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.59.0':
+    optional: true
+
+  '@rollup/rollup-openbsd-x64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-openharmony-arm64@4.59.0':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.59.0':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.59.0':
+    optional: true
+
+  '@rollup/rollup-win32-x64-gnu@4.59.0':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.59.0':
+    optional: true
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@swc/core-darwin-arm64@1.15.17':
+    optional: true
+
+  '@swc/core-darwin-x64@1.15.17':
+    optional: true
+
+  '@swc/core-linux-arm-gnueabihf@1.15.17':
+    optional: true
+
+  '@swc/core-linux-arm64-gnu@1.15.17':
+    optional: true
+
+  '@swc/core-linux-arm64-musl@1.15.17':
+    optional: true
+
+  '@swc/core-linux-x64-gnu@1.15.17':
+    optional: true
+
+  '@swc/core-linux-x64-musl@1.15.17':
+    optional: true
+
+  '@swc/core-win32-arm64-msvc@1.15.17':
+    optional: true
+
+  '@swc/core-win32-ia32-msvc@1.15.17':
+    optional: true
+
+  '@swc/core-win32-x64-msvc@1.15.17':
+    optional: true
+
+  '@swc/core@1.15.17':
+    dependencies:
+      '@swc/counter': 0.1.3
+      '@swc/types': 0.1.25
+    optionalDependencies:
+      '@swc/core-darwin-arm64': 1.15.17
+      '@swc/core-darwin-x64': 1.15.17
+      '@swc/core-linux-arm-gnueabihf': 1.15.17
+      '@swc/core-linux-arm64-gnu': 1.15.17
+      '@swc/core-linux-arm64-musl': 1.15.17
+      '@swc/core-linux-x64-gnu': 1.15.17
+      '@swc/core-linux-x64-musl': 1.15.17
+      '@swc/core-win32-arm64-msvc': 1.15.17
+      '@swc/core-win32-ia32-msvc': 1.15.17
+      '@swc/core-win32-x64-msvc': 1.15.17
+
+  '@swc/counter@0.1.3': {}
+
+  '@swc/types@0.1.25':
+    dependencies:
+      '@swc/counter': 0.1.3
+
+  '@tailwindcss/cli@4.2.1':
+    dependencies:
+      '@parcel/watcher': 2.5.6
+      '@tailwindcss/node': 4.2.1
+      '@tailwindcss/oxide': 4.2.1
+      enhanced-resolve: 5.20.0
+      mri: 1.2.0
+      picocolors: 1.1.1
+      tailwindcss: 4.2.1
+
+  '@tailwindcss/node@4.2.1':
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      enhanced-resolve: 5.20.0
+      jiti: 2.6.1
+      lightningcss: 1.31.1
+      magic-string: 0.30.21
+      source-map-js: 1.2.1
+      tailwindcss: 4.2.1
+
+  '@tailwindcss/oxide-android-arm64@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-arm64@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-x64@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-freebsd-x64@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-musl@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-wasm32-wasi@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.2.1':
+    optional: true
+
+  '@tailwindcss/oxide@4.2.1':
+    optionalDependencies:
+      '@tailwindcss/oxide-android-arm64': 4.2.1
+      '@tailwindcss/oxide-darwin-arm64': 4.2.1
+      '@tailwindcss/oxide-darwin-x64': 4.2.1
+      '@tailwindcss/oxide-freebsd-x64': 4.2.1
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.2.1
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.2.1
+      '@tailwindcss/oxide-linux-arm64-musl': 4.2.1
+      '@tailwindcss/oxide-linux-x64-gnu': 4.2.1
+      '@tailwindcss/oxide-linux-x64-musl': 4.2.1
+      '@tailwindcss/oxide-wasm32-wasi': 4.2.1
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.2.1
+      '@tailwindcss/oxide-win32-x64-msvc': 4.2.1
+
+  '@testing-library/dom@10.4.1':
+    dependencies:
+      '@babel/code-frame': 7.29.0
+      '@babel/runtime': 7.28.6
+      '@types/aria-query': 5.0.4
+      aria-query: 5.3.0
+      dom-accessibility-api: 0.5.16
+      lz-string: 1.5.0
+      picocolors: 1.1.1
+      pretty-format: 27.5.1
+
+  '@types/aria-query@5.0.4': {}
+
+  '@types/chai@5.2.3':
+    dependencies:
+      '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
+
+  '@types/deep-eql@4.0.2': {}
+
+  '@types/estree@1.0.8': {}
+
+  '@types/node@26.0.1':
+    dependencies:
+      undici-types: 8.3.0
+
+  '@types/whatwg-mimetype@3.0.2': {}
+
+  '@types/ws@8.18.1':
+    dependencies:
+      '@types/node': 26.0.1
+
+  '@vitest/coverage-v8@4.1.9(vitest@4.1.9)':
+    dependencies:
+      '@bcoe/v8-coverage': 1.0.2
+      '@vitest/utils': 4.1.9
+      ast-v8-to-istanbul: 1.0.4
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-reports: 3.2.0
+      magicast: 0.5.2
+      obug: 2.1.1
+      std-env: 4.1.0
+      tinyrainbow: 3.1.0
+      vitest: 4.1.9(@types/node@26.0.1)(@vitest/coverage-v8@4.1.9)(@vitest/ui@4.1.9)(happy-dom@20.8.9)(jsdom@26.1.0(@napi-rs/canvas@0.1.95))(vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1))
+
+  '@vitest/expect@4.1.9':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.1.9
+      '@vitest/utils': 4.1.9
+      chai: 6.2.2
+      tinyrainbow: 3.1.0
+
+  '@vitest/mocker@4.1.9(vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1))':
+    dependencies:
+      '@vitest/spy': 4.1.9
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1)
+
+  '@vitest/pretty-format@4.1.9':
+    dependencies:
+      tinyrainbow: 3.1.0
+
+  '@vitest/runner@4.1.9':
+    dependencies:
+      '@vitest/utils': 4.1.9
+      pathe: 2.0.3
+
+  '@vitest/snapshot@4.1.9':
+    dependencies:
+      '@vitest/pretty-format': 4.1.9
+      '@vitest/utils': 4.1.9
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
+  '@vitest/spy@4.1.9': {}
+
+  '@vitest/ui@4.1.9(vitest@4.1.9)':
+    dependencies:
+      '@vitest/utils': 4.1.9
+      fflate: 0.8.2
+      flatted: 3.4.2
+      pathe: 2.0.3
+      sirv: 3.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.1.0
+      vitest: 4.1.9(@types/node@26.0.1)(@vitest/coverage-v8@4.1.9)(@vitest/ui@4.1.9)(happy-dom@20.8.9)(jsdom@26.1.0(@napi-rs/canvas@0.1.95))(vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1))
+
+  '@vitest/utils@4.1.9':
+    dependencies:
+      '@vitest/pretty-format': 4.1.9
+      convert-source-map: 2.0.0
+      tinyrainbow: 3.1.0
+
+  agent-base@7.1.4: {}
+
+  ansi-regex@5.0.1: {}
+
+  ansi-styles@5.2.0: {}
+
+  aria-query@5.3.0:
+    dependencies:
+      dequal: 2.0.3
+
+  assertion-error@2.0.1: {}
+
+  ast-v8-to-istanbul@1.0.4:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      estree-walker: 3.0.3
+      js-tokens: 10.0.0
+
+  chai@6.2.2: {}
+
+  convert-source-map@2.0.0: {}
+
+  cssstyle@4.6.0:
+    dependencies:
+      '@asamuzakjp/css-color': 3.2.0
+      rrweb-cssom: 0.8.0
+
+  data-urls@5.0.0:
+    dependencies:
+      whatwg-mimetype: 4.0.0
+      whatwg-url: 14.2.0
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  decimal.js@10.6.0: {}
+
+  dequal@2.0.3: {}
+
+  detect-libc@2.1.2: {}
+
+  dom-accessibility-api@0.5.16: {}
+
+  enhanced-resolve@5.20.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      tapable: 2.3.0
+
+  entities@6.0.1: {}
+
+  entities@7.0.1: {}
+
+  es-module-lexer@2.1.0: {}
+
+  esbuild@0.27.3:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.3
+      '@esbuild/android-arm': 0.27.3
+      '@esbuild/android-arm64': 0.27.3
+      '@esbuild/android-x64': 0.27.3
+      '@esbuild/darwin-arm64': 0.27.3
+      '@esbuild/darwin-x64': 0.27.3
+      '@esbuild/freebsd-arm64': 0.27.3
+      '@esbuild/freebsd-x64': 0.27.3
+      '@esbuild/linux-arm': 0.27.3
+      '@esbuild/linux-arm64': 0.27.3
+      '@esbuild/linux-ia32': 0.27.3
+      '@esbuild/linux-loong64': 0.27.3
+      '@esbuild/linux-mips64el': 0.27.3
+      '@esbuild/linux-ppc64': 0.27.3
+      '@esbuild/linux-riscv64': 0.27.3
+      '@esbuild/linux-s390x': 0.27.3
+      '@esbuild/linux-x64': 0.27.3
+      '@esbuild/netbsd-arm64': 0.27.3
+      '@esbuild/netbsd-x64': 0.27.3
+      '@esbuild/openbsd-arm64': 0.27.3
+      '@esbuild/openbsd-x64': 0.27.3
+      '@esbuild/openharmony-arm64': 0.27.3
+      '@esbuild/sunos-x64': 0.27.3
+      '@esbuild/win32-arm64': 0.27.3
+      '@esbuild/win32-ia32': 0.27.3
+      '@esbuild/win32-x64': 0.27.3
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  expect-type@1.3.0: {}
+
+  fdir@6.5.0(picomatch@4.0.3):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  fflate@0.8.2: {}
+
+  flatted@3.4.2: {}
+
+  fsevents@2.3.2:
+    optional: true
+
+  fsevents@2.3.3:
+    optional: true
+
+  graceful-fs@4.2.11: {}
+
+  happy-dom@20.8.9:
+    dependencies:
+      '@types/node': 26.0.1
+      '@types/whatwg-mimetype': 3.0.2
+      '@types/ws': 8.18.1
+      entities: 7.0.1
+      whatwg-mimetype: 3.0.0
+      ws: 8.21.0
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  has-flag@4.0.0: {}
+
+  heroicons@2.2.0: {}
+
+  html-encoding-sniffer@4.0.0:
+    dependencies:
+      whatwg-encoding: 3.1.1
+
+  html-escaper@2.0.2: {}
+
+  http-proxy-agent@7.0.2:
+    dependencies:
+      agent-base: 7.1.4
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  https-proxy-agent@7.0.6:
+    dependencies:
+      agent-base: 7.1.4
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  iconv-lite@0.6.3:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  is-extglob@2.1.1: {}
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-potential-custom-element-name@1.0.1: {}
+
+  istanbul-lib-coverage@3.2.2: {}
+
+  istanbul-lib-report@3.0.1:
+    dependencies:
+      istanbul-lib-coverage: 3.2.2
+      make-dir: 4.0.0
+      supports-color: 7.2.0
+
+  istanbul-reports@3.2.0:
+    dependencies:
+      html-escaper: 2.0.2
+      istanbul-lib-report: 3.0.1
+
+  jiti@2.6.1: {}
+
+  js-tokens@10.0.0: {}
+
+  js-tokens@4.0.0: {}
+
+  jsdom@26.1.0(@napi-rs/canvas@0.1.95):
+    dependencies:
+      cssstyle: 4.6.0
+      data-urls: 5.0.0
+      decimal.js: 10.6.0
+      html-encoding-sniffer: 4.0.0
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      is-potential-custom-element-name: 1.0.1
+      nwsapi: 2.2.23
+      parse5: 7.3.0
+      rrweb-cssom: 0.8.0
+      saxes: 6.0.0
+      symbol-tree: 3.2.4
+      tough-cookie: 5.1.2
+      w3c-xmlserializer: 5.0.0
+      webidl-conversions: 7.0.0
+      whatwg-encoding: 3.1.1
+      whatwg-mimetype: 4.0.0
+      whatwg-url: 14.2.0
+      ws: 8.19.0
+      xml-name-validator: 5.0.0
+    optionalDependencies:
+      canvas: '@napi-rs/canvas@0.1.95'
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  lightningcss-android-arm64@1.31.1:
+    optional: true
+
+  lightningcss-darwin-arm64@1.31.1:
+    optional: true
+
+  lightningcss-darwin-x64@1.31.1:
+    optional: true
+
+  lightningcss-freebsd-x64@1.31.1:
+    optional: true
+
+  lightningcss-linux-arm-gnueabihf@1.31.1:
+    optional: true
+
+  lightningcss-linux-arm64-gnu@1.31.1:
+    optional: true
+
+  lightningcss-linux-arm64-musl@1.31.1:
+    optional: true
+
+  lightningcss-linux-x64-gnu@1.31.1:
+    optional: true
+
+  lightningcss-linux-x64-musl@1.31.1:
+    optional: true
+
+  lightningcss-win32-arm64-msvc@1.31.1:
+    optional: true
+
+  lightningcss-win32-x64-msvc@1.31.1:
+    optional: true
+
+  lightningcss@1.31.1:
+    dependencies:
+      detect-libc: 2.1.2
+    optionalDependencies:
+      lightningcss-android-arm64: 1.31.1
+      lightningcss-darwin-arm64: 1.31.1
+      lightningcss-darwin-x64: 1.31.1
+      lightningcss-freebsd-x64: 1.31.1
+      lightningcss-linux-arm-gnueabihf: 1.31.1
+      lightningcss-linux-arm64-gnu: 1.31.1
+      lightningcss-linux-arm64-musl: 1.31.1
+      lightningcss-linux-x64-gnu: 1.31.1
+      lightningcss-linux-x64-musl: 1.31.1
+      lightningcss-win32-arm64-msvc: 1.31.1
+      lightningcss-win32-x64-msvc: 1.31.1
+
+  lru-cache@10.4.3: {}
+
+  lz-string@1.5.0: {}
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  magicast@0.5.2:
+    dependencies:
+      '@babel/parser': 7.29.0
+      '@babel/types': 7.29.0
+      source-map-js: 1.2.1
+
+  make-dir@4.0.0:
+    dependencies:
+      semver: 7.7.4
+
+  mri@1.2.0: {}
+
+  mrmime@2.0.1: {}
+
+  ms@2.1.3: {}
+
+  nanoid@3.3.11: {}
+
+  node-addon-api@7.1.1: {}
+
+  nwsapi@2.2.23: {}
+
+  obug@2.1.1: {}
+
+  parse5@7.3.0:
+    dependencies:
+      entities: 6.0.1
+
+  pathe@2.0.3: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@4.0.3: {}
+
+  playwright-core@1.58.2: {}
+
+  playwright@1.58.2:
+    dependencies:
+      playwright-core: 1.58.2
+    optionalDependencies:
+      fsevents: 2.3.2
+
+  postcss@8.5.6:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  pretty-format@27.5.1:
+    dependencies:
+      ansi-regex: 5.0.1
+      ansi-styles: 5.2.0
+      react-is: 17.0.2
+
+  punycode@2.3.1: {}
+
+  react-is@17.0.2: {}
+
+  rollup@4.59.0:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.59.0
+      '@rollup/rollup-android-arm64': 4.59.0
+      '@rollup/rollup-darwin-arm64': 4.59.0
+      '@rollup/rollup-darwin-x64': 4.59.0
+      '@rollup/rollup-freebsd-arm64': 4.59.0
+      '@rollup/rollup-freebsd-x64': 4.59.0
+      '@rollup/rollup-linux-arm-gnueabihf': 4.59.0
+      '@rollup/rollup-linux-arm-musleabihf': 4.59.0
+      '@rollup/rollup-linux-arm64-gnu': 4.59.0
+      '@rollup/rollup-linux-arm64-musl': 4.59.0
+      '@rollup/rollup-linux-loong64-gnu': 4.59.0
+      '@rollup/rollup-linux-loong64-musl': 4.59.0
+      '@rollup/rollup-linux-ppc64-gnu': 4.59.0
+      '@rollup/rollup-linux-ppc64-musl': 4.59.0
+      '@rollup/rollup-linux-riscv64-gnu': 4.59.0
+      '@rollup/rollup-linux-riscv64-musl': 4.59.0
+      '@rollup/rollup-linux-s390x-gnu': 4.59.0
+      '@rollup/rollup-linux-x64-gnu': 4.59.0
+      '@rollup/rollup-linux-x64-musl': 4.59.0
+      '@rollup/rollup-openbsd-x64': 4.59.0
+      '@rollup/rollup-openharmony-arm64': 4.59.0
+      '@rollup/rollup-win32-arm64-msvc': 4.59.0
+      '@rollup/rollup-win32-ia32-msvc': 4.59.0
+      '@rollup/rollup-win32-x64-gnu': 4.59.0
+      '@rollup/rollup-win32-x64-msvc': 4.59.0
+      fsevents: 2.3.3
+
+  rrweb-cssom@0.8.0: {}
+
+  safer-buffer@2.1.2: {}
+
+  saxes@6.0.0:
+    dependencies:
+      xmlchars: 2.2.0
+
+  semver@7.7.4: {}
+
+  siginfo@2.0.0: {}
+
+  sirv@3.0.2:
+    dependencies:
+      '@polka/url': 1.0.0-next.29
+      mrmime: 2.0.1
+      totalist: 3.0.1
+
+  source-map-js@1.2.1: {}
+
+  stackback@0.0.2: {}
+
+  std-env@4.1.0: {}
+
+  supports-color@7.2.0:
+    dependencies:
+      has-flag: 4.0.0
+
+  symbol-tree@3.2.4: {}
+
+  tailwindcss@4.2.1: {}
+
+  tapable@2.3.0: {}
+
+  tinybench@2.9.0: {}
+
+  tinyexec@1.0.2: {}
+
+  tinyglobby@0.2.15:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  tinyrainbow@3.1.0: {}
+
+  tldts-core@6.1.86: {}
+
+  tldts@6.1.86:
+    dependencies:
+      tldts-core: 6.1.86
+
+  totalist@3.0.1: {}
+
+  tough-cookie@5.1.2:
+    dependencies:
+      tldts: 6.1.86
+
+  tr46@5.1.1:
+    dependencies:
+      punycode: 2.3.1
+
+  undici-types@8.3.0: {}
+
+  vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1):
+    dependencies:
+      esbuild: 0.27.3
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.59.0
+      tinyglobby: 0.2.15
+    optionalDependencies:
+      '@types/node': 26.0.1
+      fsevents: 2.3.3
+      jiti: 2.6.1
+      lightningcss: 1.31.1
+
+  vitest@4.1.9(@types/node@26.0.1)(@vitest/coverage-v8@4.1.9)(@vitest/ui@4.1.9)(happy-dom@20.8.9)(jsdom@26.1.0(@napi-rs/canvas@0.1.95))(vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1)):
+    dependencies:
+      '@vitest/expect': 4.1.9
+      '@vitest/mocker': 4.1.9(vite@7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1))
+      '@vitest/pretty-format': 4.1.9
+      '@vitest/runner': 4.1.9
+      '@vitest/snapshot': 4.1.9
+      '@vitest/spy': 4.1.9
+      '@vitest/utils': 4.1.9
+      es-module-lexer: 2.1.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.1
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 4.1.0
+      tinybench: 2.9.0
+      tinyexec: 1.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.1.0
+      vite: 7.3.6(@types/node@26.0.1)(jiti@2.6.1)(lightningcss@1.31.1)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 26.0.1
+      '@vitest/coverage-v8': 4.1.9(vitest@4.1.9)
+      '@vitest/ui': 4.1.9(vitest@4.1.9)
+      happy-dom: 20.8.9
+      jsdom: 26.1.0(@napi-rs/canvas@0.1.95)
+    transitivePeerDependencies:
+      - msw
+
+  w3c-xmlserializer@5.0.0:
+    dependencies:
+      xml-name-validator: 5.0.0
+
+  webidl-conversions@7.0.0: {}
+
+  whatwg-encoding@3.1.1:
+    dependencies:
+      iconv-lite: 0.6.3
+
+  whatwg-mimetype@3.0.0: {}
+
+  whatwg-mimetype@4.0.0: {}
+
+  whatwg-url@14.2.0:
+    dependencies:
+      tr46: 5.1.1
+      webidl-conversions: 7.0.0
+
+  why-is-node-running@2.3.0:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
+
+  ws@8.19.0: {}
+
+  ws@8.21.0: {}
+
+  xml-name-validator@5.0.0: {}
+
+  xmlchars@2.2.0: {}

pyproject.toml

@@ -0,0 +1,118 @@
+[build-system]
+requires = ["uv_build>=0.9.26"]
+build-backend = "uv_build"
+
+[project]
+name = "aspara"
+version = "0.1.0"
+description = "Blazingly fast metrics tracker for machine learning experiments"
+authors = [
+    {name = "TOKUNAGA Hiroyuki"}
+]
+license = "Apache-2.0"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "polars>=1.37.1",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+tracker = [
+    "uvicorn>=0.27.0",
+    "fastapi>=0.115.12",
+    "starlette>=1.3.1",
+    "python-multipart>=0.0.31",
+]
+
+dashboard = [
+    "uvicorn>=0.27.0",
+    "sse-starlette>=1.8.0",
+    "starlette>=1.3.1",
+    "aiofiles>=23.2.0",
+    "watchfiles>=1.1.1",
+    "pystache>=0.6.8",
+    "fastapi>=0.115.12",
+    "lttb>=0.3.2",
+    "numpy>=1.24.0",
+    "msgpack>=1.2.1",
+]
+
+remote = [
+    "requests>=2.31.0",
+    "urllib3>=2.7.0",
+    "idna>=3.15",
+]
+
+tui = [
+    "textual>=0.47.0",
+    "textual-plotext>=0.2.0",
+]
+
+all = [
+    "aspara[tracker]",
+    "aspara[dashboard]",
+    "aspara[remote]",
+    "aspara[tui]",
+    "aspara[docs]",
+]
+
+docs = [
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.6.0",
+    "mkdocstrings[python]>=0.24.0",
+    "mkdocs-autorefs>=0.5.0",
+]
+
+[project.scripts]
+aspara = "aspara.cli:main"
+
+[dependency-groups]
+dev = [
+    "aspara[all]",
+    "pytest>=9.0.3",
+    "pytest-asyncio>=1.0.0",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.14.10",
+    "playwright>=1.52.0",
+    "pyrefly>=0.46.1",
+    "py-spy>=0.4.1",
+    "types-requests>=2.31.0",
+    "ty>=0.0.12",
+    "httpx>=0.28.1",
+]
+
+[tool.ruff]
+line-length = 160
+indent-width = 4
+target-version = "py310"
+extend-exclude = [".venv", "build", "dist"]
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "B", "I"]
+extend-select = [
+    "C4",   # flake8-comprehensions
+    "SIM",  # flake8-simplify
+    "ERA",  # eradicate
+    "UP",   # pyupgrade
+]
+extend-ignore = ["SIM108"]
+
+[tool.pyrefly]
+project-includes = [
+    "src/**/*.py*",
+    "tests/**/*.py*",
+]
+
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+preview = true
+line-ending = "auto"
+docstring-code-format = true
+
+[tool.ruff.lint.isort]
+known-first-party = ["aspara"]
+section-order = ["future", "standard-library", "third-party", "first-party", "local-folder"]

scripts/build-icons.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Build script to generate SVG symbol sprites from heroicons.
+ *
+ * Reads icons.config.json and generates _icons.mustache partial
+ * containing SVG symbols that can be referenced via <use href="#id">.
+ *
+ * Usage: node scripts/build-icons.js
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = join(__dirname, '..');
+
+const CONFIG_PATH = join(ROOT_DIR, 'icons.config.json');
+const OUTPUT_PATH = join(ROOT_DIR, 'src/aspara/dashboard/templates/_icons.mustache');
+const HEROICONS_PATH = join(ROOT_DIR, 'node_modules/heroicons/24');
+
+/**
+ * Parse SVG file and extract attributes and inner content.
+ * @param {string} svgContent - Raw SVG file content
+ * @returns {{ attrs: Object, innerContent: string }}
+ */
+function parseSvg(svgContent) {
+  // Extract attributes from the opening <svg> tag
+  const svgMatch = svgContent.match(/<svg([^>]*)>([\s\S]*)<\/svg>/);
+  if (!svgMatch) {
+    throw new Error('Invalid SVG format');
+  }
+
+  const attrsString = svgMatch[1];
+  const innerContent = svgMatch[2].trim();
+
+  // Parse attributes
+  const attrs = {};
+  const attrRegex = /(\S+)=["']([^"']*)["']/g;
+  for (const match of attrsString.matchAll(attrRegex)) {
+    attrs[match[1]] = match[2];
+  }
+
+  return { attrs, innerContent };
+}
+
+/**
+ * Convert SVG to symbol element.
+ * @param {string} svgContent - Raw SVG file content
+ * @param {string} id - Symbol ID
+ * @returns {string} Symbol element string
+ */
+function svgToSymbol(svgContent, id) {
+  const { attrs, innerContent } = parseSvg(svgContent);
+
+  // Build symbol attributes (keep viewBox, fill, stroke, stroke-width)
+  const symbolAttrs = [`id="${id}"`];
+
+  if (attrs.viewBox) {
+    symbolAttrs.push(`viewBox="${attrs.viewBox}"`);
+  }
+  if (attrs.fill) {
+    symbolAttrs.push(`fill="${attrs.fill}"`);
+  }
+  if (attrs.stroke) {
+    symbolAttrs.push(`stroke="${attrs.stroke}"`);
+  }
+  if (attrs['stroke-width']) {
+    symbolAttrs.push(`stroke-width="${attrs['stroke-width']}"`);
+  }
+
+  return `    <symbol ${symbolAttrs.join(' ')}>\n      ${innerContent}\n    </symbol>`;
+}
+
+/**
+ * Main build function.
+ */
+function build() {
+  console.log('Building icon sprites...');
+
+  // Read config
+  const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  console.log(`Found ${config.icons.length} icons in config`);
+
+  const symbols = [];
+
+  for (const icon of config.icons) {
+    const svgPath = join(HEROICONS_PATH, icon.style, `${icon.name}.svg`);
+    console.log(`  Processing: ${icon.name} (${icon.style}) -> #${icon.id}`);
+
+    try {
+      const svgContent = readFileSync(svgPath, 'utf-8');
+      const symbol = svgToSymbol(svgContent, icon.id);
+      symbols.push(symbol);
+    } catch (err) {
+      console.error(`  Error reading ${svgPath}: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Generate output
+  const output = `{{!
+  Auto-generated icon sprites from heroicons.
+  Do not edit manually - run "pnpm build:icons" to regenerate.
+
+  Source: icons.config.json
+}}
+<svg style="display: none" aria-hidden="true">
+${symbols.join('\n')}
+</svg>
+`;
+
+  writeFileSync(OUTPUT_PATH, output);
+  console.log(`\nGenerated: ${OUTPUT_PATH}`);
+  console.log('Done!');
+}
+
+build();

space_README.md

@@ -0,0 +1,27 @@
+---
+title: Aspara Demo
+emoji: 🌱
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Aspara Demo
+
+Aspara — a blazingly fast metrics tracker for machine learning experiments.
+
+This Space runs a demo dashboard with pre-generated sample data.
+Browse projects, compare runs, and explore metrics to see what Aspara can do.
+
+## Features
+
+- LTTB-based metric downsampling for responsive charts
+- Run comparison with overlay charts
+- Tag and note editing
+- Real-time updates via SSE
+
+## Links
+
+- [GitHub Repository](https://github.com/prednext/aspara)

src/aspara/__init__.py

@@ -0,0 +1,31 @@
+"""
+Aspara - Simple metrics tracking system for machine learning experiments.
+
+This module provides a wandb-compatible API for experiment tracking.
+
+Examples:
+    >>> import aspara
+    >>> run = aspara.init(project="my_project", config={"lr": 0.01})
+    >>> aspara.log({"loss": 0.5, "accuracy": 0.95})
+    >>> aspara.finish()
+"""
+
+from aspara.run import Config, Run, Summary, finish, init, log
+from aspara.run import get_current_run as _get_current_run
+
+__version__ = "0.1.0"
+__all__ = [
+    "Run",
+    "Config",
+    "Summary",
+    "init",
+    "log",
+    "finish",
+]
+
+
+# Convenience function for accessing current run's config
+def config() -> Config | None:
+    """Get the config of the current run."""
+    run = _get_current_run()
+    return run.config if run else None

src/aspara/catalog/__init__.py

@@ -0,0 +1,18 @@
+"""
+Aspara Catalog module
+
+Provides ProjectCatalog and RunCatalog for discovering and managing
+projects and runs in the data directory.
+"""
+
+from .project_catalog import ProjectCatalog, ProjectInfo
+from .run_catalog import RunCatalog, RunInfo
+from .watcher import DataDirWatcher
+
+__all__ = [
+    "ProjectCatalog",
+    "RunCatalog",
+    "ProjectInfo",
+    "RunInfo",
+    "DataDirWatcher",
+]

src/aspara/catalog/project_catalog.py

@@ -0,0 +1,242 @@
+"""
+ProjectCatalog - Catalog for discovering and managing projects.
+
+This module provides functionality for listing, getting, and deleting projects
+in the data directory.
+"""
+
+import logging
+import os
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from aspara.exceptions import ProjectNotFoundError
+from aspara.storage import ProjectMetadataStorage
+from aspara.utils.validators import validate_name, validate_safe_path
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectInfo(BaseModel):
+    """Project information."""
+
+    name: str
+    run_count: int
+    last_update: datetime
+
+
+# Run data file suffixes used when discovering and counting runs.
+_RUN_DATA_SUFFIXES = (".jsonl", ".db", ".wal")
+_RUN_EXCLUDED_SUFFIXES = (".wal.jsonl", ".meta.jsonl")
+
+
+class ProjectCatalog:
+    """Catalog for discovering and managing projects.
+
+    This class provides methods to list, get, and delete projects
+    in the data directory. It does not handle metrics data directly;
+    that responsibility belongs to MetricsStorage.
+    """
+
+    def __init__(self, data_dir: str | Path) -> None:
+        """Initialize the project catalog.
+
+        Args:
+            data_dir: Base directory for data storage
+        """
+        self.data_dir = Path(data_dir)
+
+    def _scan_projects(self, *, include_metadata: bool = False) -> list[tuple[ProjectInfo, dict[str, Any] | None]]:
+        """Scan the data directory and build project information.
+
+        Args:
+            include_metadata: Whether to load project metadata.json during the scan.
+
+        Returns:
+            List of (ProjectInfo, metadata) tuples. ``metadata`` is ``None`` when
+            ``include_metadata`` is ``False``.
+        """
+        results: list[tuple[ProjectInfo, dict[str, Any] | None]] = []
+        if not self.data_dir.exists():
+            return results
+
+        try:
+            # Use scandir for efficient iteration with cached stat info
+            with os.scandir(self.data_dir) as project_entries:
+                for project_entry in project_entries:
+                    if not project_entry.is_dir():
+                        continue
+
+                    # Skip hidden/reserved directories (e.g. .queue)
+                    if project_entry.name.startswith("."):
+                        continue
+
+                    # Collect run files and optionally metadata in a single pass
+                    run_files_mtime: list[float] = []
+                    metadata: dict[str, Any] | None = None
+                    with os.scandir(project_entry.path) as file_entries:
+                        for file_entry in file_entries:
+                            if include_metadata and file_entry.name == "metadata.json":
+                                metadata = ProjectMetadataStorage.load_metadata_file(Path(file_entry.path))
+                            elif file_entry.name.endswith(_RUN_DATA_SUFFIXES) and not file_entry.name.endswith(_RUN_EXCLUDED_SUFFIXES):
+                                # stat() result is cached by scandir
+                                run_files_mtime.append(file_entry.stat().st_mtime)
+
+                    if include_metadata and metadata is None:
+                        metadata = ProjectMetadataStorage.default_metadata()
+
+                    run_count = len(run_files_mtime)
+
+                    # Find last update time - use cached stat from scandir
+                    if run_files_mtime:
+                        last_update = datetime.fromtimestamp(max(run_files_mtime), tz=timezone.utc)
+                    else:
+                        last_update = datetime.fromtimestamp(project_entry.stat().st_mtime, tz=timezone.utc)
+
+                    results.append((
+                        ProjectInfo(
+                            name=project_entry.name,
+                            run_count=run_count,
+                            last_update=last_update,
+                        ),
+                        metadata,
+                    ))
+        except (OSError, PermissionError):
+            pass
+
+        return sorted(results, key=lambda item: item[0].name)
+
+    def get_projects(self) -> list[ProjectInfo]:
+        """List all projects in the data directory.
+
+        Uses os.scandir() for efficient directory iteration with cached stat info.
+
+        Returns:
+            List of ProjectInfo objects sorted by name
+        """
+        return [project for project, _ in self._scan_projects(include_metadata=False)]
+
+    def get_projects_with_metadata(self) -> list[tuple[ProjectInfo, dict[str, Any]]]:
+        """List all projects with their metadata in a single directory pass.
+
+        Returns:
+            List of (ProjectInfo, metadata) tuples sorted by project name.
+        """
+        return [(project, metadata) for project, metadata in self._scan_projects(include_metadata=True) if metadata is not None]
+
+    def get(self, name: str) -> ProjectInfo:
+        """Get a specific project by name.
+
+        Args:
+            name: Project name
+
+        Returns:
+            ProjectInfo object
+
+        Raises:
+            ValueError: If project name is invalid
+            ProjectNotFoundError: If project does not exist
+        """
+        validate_name(name, "project name")
+
+        project_dir = self.data_dir / name
+        validate_safe_path(project_dir, self.data_dir)
+
+        if not project_dir.exists() or not project_dir.is_dir():
+            raise ProjectNotFoundError(f"Project '{name}' not found")
+
+        # Count runs and collect mtimes in a single scandir pass, using the same
+        # suffix logic as get_projects() for consistency and reduced I/O.
+        run_files_mtime: list[float] = []
+        try:
+            with os.scandir(project_dir) as file_entries:
+                for file_entry in file_entries:
+                    if file_entry.name.endswith(_RUN_DATA_SUFFIXES) and not file_entry.name.endswith(_RUN_EXCLUDED_SUFFIXES):
+                        run_files_mtime.append(file_entry.stat().st_mtime)
+        except (OSError, PermissionError):
+            pass
+
+        run_count = len(run_files_mtime)
+
+        # Get last update time from run files
+        last_update = datetime.fromtimestamp(project_dir.stat().st_mtime, tz=timezone.utc)
+        if run_files_mtime:
+            last_update = datetime.fromtimestamp(max(run_files_mtime), tz=timezone.utc)
+
+        return ProjectInfo(
+            name=name,
+            run_count=run_count,
+            last_update=last_update,
+        )
+
+    def exists(self, name: str) -> bool:
+        """Check if a project exists.
+
+        Args:
+            name: Project name
+
+        Returns:
+            True if project exists, False otherwise
+        """
+        try:
+            validate_name(name, "project name")
+            project_dir = self.data_dir / name
+            validate_safe_path(project_dir, self.data_dir)
+            return project_dir.exists() and project_dir.is_dir()
+        except ValueError:
+            return False
+
+    def delete(self, name: str) -> None:
+        """Delete a project and all its runs.
+
+        Args:
+            name: Project name to delete
+
+        Raises:
+            ValueError: If project name is empty or invalid
+            ProjectNotFoundError: If project does not exist
+            PermissionError: If deletion is not permitted
+        """
+        if not name:
+            raise ValueError("Project name cannot be empty")
+
+        validate_name(name, "project name")
+
+        project_dir = self.data_dir / name
+        validate_safe_path(project_dir, self.data_dir)
+
+        if not project_dir.exists():
+            raise ProjectNotFoundError(f"Project '{name}' does not exist")
+
+        try:
+            shutil.rmtree(project_dir)
+            logger.info(f"Successfully deleted project: {name}")
+        except (PermissionError, OSError) as e:
+            logger.error(f"Error deleting project {name}: {type(e).__name__}")
+            raise
+
+    def get_metadata(self, name: str) -> dict[str, Any]:
+        """Get project-level metadata.json for a project.
+
+        Returns a dictionary with notes, tags, created_at, updated_at fields.
+        """
+        storage = ProjectMetadataStorage(self.data_dir, name)
+        return storage.get_metadata()
+
+    def update_metadata(self, name: str, metadata: dict[str, Any]) -> dict[str, Any]:
+        """Update project-level metadata.json for a project.
+
+        The metadata dict may contain partial fields (notes, tags).
+        Validation and timestamp handling is delegated to ProjectMetadataStorage.
+        """
+        storage = ProjectMetadataStorage(self.data_dir, name)
+        return storage.update_metadata(metadata)
+
+    def delete_metadata(self, name: str) -> bool:
+        """Delete project-level metadata.json for a project."""
+        storage = ProjectMetadataStorage(self.data_dir, name)
+        return storage.delete_metadata()

src/aspara/catalog/run_catalog.py

@@ -0,0 +1,764 @@
+"""
+RunCatalog - Catalog for discovering and managing runs within a project.
+
+This module provides functionality for listing, getting, and deleting runs
+in a project directory.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+import shutil
+from collections.abc import AsyncGenerator, Mapping
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import polars as pl
+from pydantic import BaseModel, Field
+
+from aspara.exceptions import ProjectNotFoundError, RunNotFoundError
+from aspara.models import MetricRecord, RunStatus, StatusRecord
+from aspara.storage import RunMetadataStorage
+from aspara.utils.timestamp import parse_to_datetime
+from aspara.utils.validators import validate_name, validate_safe_path
+
+logger = logging.getLogger(__name__)
+
+# Threshold in seconds to consider a run as potentially failed (1 hour)
+STALE_RUN_THRESHOLD_SECONDS = 3600
+
+
+class RunInfo(BaseModel):
+    """Run information."""
+
+    name: str
+    run_id: str | None = None
+    start_time: datetime | None = None
+    last_update: datetime | None = None
+    param_count: int
+    artifact_count: int = 0
+    tags: list[str] = []
+    is_corrupted: bool = False
+    error_message: str | None = None
+    is_finished: bool = False
+    exit_code: int | None = None
+    status: RunStatus = Field(default=RunStatus.WIP)
+
+
+def _detect_backend(data_dir: Path, project: str, run_name: str) -> str:
+    """Detect which storage backend a run is using.
+
+    Args:
+        data_dir: Base data directory
+        project: Project name
+        run_name: Run name
+
+    Returns:
+        "polars" if the run uses Polars backend (WAL + Parquet), "jsonl" otherwise
+    """
+    project_dir = data_dir / project
+
+    # Check for Polars backend indicators
+    wal_file = project_dir / f"{run_name}.wal.jsonl"
+    archive_dir = project_dir / f"{run_name}_archive"
+
+    # If WAL file or archive directory exists, it's a Polars backend
+    if wal_file.exists() or archive_dir.exists():
+        return "polars"
+
+    # Otherwise, it's JSONL backend
+    return "jsonl"
+
+
+def _open_metrics_storage(
+    base_dir: Path | str,
+    project: str,
+    run_name: str,
+):
+    """Open metrics storage for an existing run.
+
+    Detects the backend type from existing files and returns
+    the appropriate storage instance.
+
+    Args:
+        base_dir: Base data directory
+        project: Project name
+        run_name: Run name
+
+    Returns:
+        JsonlMetricsStorage or PolarsMetricsStorage instance
+    """
+    from aspara.storage import JsonlMetricsStorage, PolarsMetricsStorage
+
+    backend = _detect_backend(Path(base_dir), project, run_name)
+
+    if backend == "polars":
+        return PolarsMetricsStorage(
+            base_dir=str(base_dir),
+            project_name=project,
+            run_name=run_name,
+        )
+    else:
+        return JsonlMetricsStorage(
+            base_dir=str(base_dir),
+            project_name=project,
+            run_name=run_name,
+        )
+
+
+def _read_metadata_file(metadata_file: Path) -> dict:
+    """Read .meta.json file and return parsed data.
+
+    Args:
+        metadata_file: Path to the .meta.json file
+
+    Returns:
+        Dictionary with metadata, or empty dict if file doesn't exist or is invalid
+    """
+    if not metadata_file.exists():
+        return {}
+
+    try:
+        with open(metadata_file) as f:
+            return json.load(f)
+    except Exception as e:
+        logger.warning(f"Error reading metadata file {metadata_file}: {e}")
+        return {}
+
+
+def _infer_stale_status(
+    status: RunStatus,
+    start_time: datetime | None,
+    is_finished: bool,
+) -> RunStatus:
+    """Infer MAYBE_FAILED status for old runs that were never finished.
+
+    Args:
+        status: Current run status
+        start_time: When the run started
+        is_finished: Whether the run has finished
+
+    Returns:
+        MAYBE_FAILED if run is stale, otherwise the original status
+    """
+    if status != RunStatus.WIP or not start_time or is_finished:
+        return status
+
+    current_time = datetime.now(timezone.utc)
+    age_seconds = (current_time - start_time).total_seconds()
+    if age_seconds > STALE_RUN_THRESHOLD_SECONDS:
+        return RunStatus.MAYBE_FAILED
+
+    return status
+
+
+def _extract_timestamp_range(
+    df: pl.DataFrame,
+) -> tuple[datetime | None, datetime | None]:
+    """Extract start_time and last_update from DataFrame.
+
+    Args:
+        df: DataFrame with timestamp column
+
+    Returns:
+        Tuple of (start_time, last_update)
+    """
+    if len(df) == 0 or "timestamp" not in df.columns:
+        return (None, None)
+
+    timestamps = df.select("timestamp").to_series()
+    if len(timestamps) == 0:
+        return (None, None)
+
+    ts_min = timestamps.min()
+    ts_max = timestamps.max()
+
+    start_time = ts_min if isinstance(ts_min, datetime) else None
+    last_update = ts_max if isinstance(ts_max, datetime) else None
+
+    return (start_time, last_update)
+
+
+def _check_corruption(
+    df: pl.DataFrame,
+    metadata_file_exists: bool,
+) -> tuple[bool, str | None]:
+    """Check if metrics data is corrupted.
+
+    Args:
+        df: DataFrame with metrics
+        metadata_file_exists: Whether metadata file exists
+
+    Returns:
+        Tuple of (is_corrupted, error_message)
+    """
+    if len(df) == 0 and not metadata_file_exists:
+        return (True, "Empty file! No data found!")
+    if len(df) > 0 and "timestamp" not in df.columns:
+        return (True, "No timestamps found! Corrupted Run!")
+    return (False, None)
+
+
+def _map_error_to_corruption(
+    error: Exception,
+    metadata_file_exists: bool,
+) -> tuple[bool, str | None]:
+    """Map storage read errors to corruption status.
+
+    Args:
+        error: The exception that occurred
+        metadata_file_exists: Whether metadata file exists
+
+    Returns:
+        Tuple of (is_corrupted, error_message)
+    """
+    error_str = str(error).lower()
+
+    if "empty" in error_str or "empty string" in error_str:
+        return (True, "Empty file! No data found!")
+    if "expectedobjectkey" in error_str.replace(" ", "") or "invalid json" in error_str:
+        return (True, f"Invalid file format! Error: {error!s}")
+    if "timestamp" in error_str:
+        return (True, f"No timestamps found! Error: {error!s}")
+    if "step" in error_str and not metadata_file_exists:
+        return (True, f"Failed to read metrics: {error!s}")
+    if not metadata_file_exists:
+        return (True, f"Failed to read metrics: {error!s}")
+
+    return (False, None)
+
+
+class RunCatalog:
+    """Catalog for discovering and managing runs within a project.
+
+    This class provides methods to list, get, delete, and watch runs.
+    It handles both JSONL and DuckDB storage formats.
+    """
+
+    def __init__(self, data_dir: str | Path) -> None:
+        """Initialize the run catalog.
+
+        Args:
+            data_dir: Base directory for data storage
+        """
+        self.data_dir = Path(data_dir)
+
+    def _parse_file_path(self, file_path: Path) -> tuple[str, str, str] | None:
+        """Parse file path to extract project, run name, and file type.
+
+        Args:
+            file_path: Absolute path to a file (e.g., data/project/run.jsonl)
+
+        Returns:
+            (project, run_name, file_type) where file_type is 'metrics', 'wal', or 'meta'
+            None if path doesn't match expected pattern or names are invalid
+        """
+        try:
+            relative = file_path.relative_to(self.data_dir)
+        except ValueError:
+            return None
+
+        parts = relative.parts
+        if len(parts) != 2:
+            return None
+
+        project = parts[0]
+        filename = parts[1]
+
+        if filename.endswith(".wal.jsonl"):
+            run_name = filename[:-10]
+            file_type = "wal"
+        elif filename.endswith(".meta.json"):
+            run_name = filename[:-10]
+            file_type = "meta"
+        elif filename.endswith(".jsonl"):
+            run_name = filename[:-6]
+            file_type = "metrics"
+        else:
+            return None
+
+        # Validate project and run names so that reserved/hidden directories
+        # (e.g. .queue) or names with path-traversal characters are rejected
+        # at parse time rather than leaking into downstream consumers.
+        try:
+            validate_name(project, "project name")
+            validate_name(run_name, "run name")
+        except ValueError:
+            return None
+
+        return (project, run_name, file_type)
+
+    def _read_run_info(self, project: str, run_name: str, run_file: Path) -> RunInfo:
+        """Read run information from JSONL metrics file and metadata file.
+
+        Supports both JSONL and Polars backends.
+        Optimization: Avoids loading full DataFrame when metadata provides sufficient info.
+
+        Args:
+            project: Project name
+            run_name: Run name
+            run_file: Path to the JSONL metrics file
+
+        Returns:
+            RunInfo object with metadata from both files
+        """
+        metadata_file = run_file.parent / f"{run_name}.meta.json"
+
+        # Read metadata
+        metadata = _read_metadata_file(metadata_file)
+        run_id = metadata.get("run_id")
+        tags = metadata.get("tags", [])
+        is_finished = metadata.get("is_finished", False)
+        exit_code = metadata.get("exit_code")
+
+        # Read params count
+        params = metadata.get("params", {})
+        params_count = len(params) if isinstance(params, dict) else 0
+
+        # Parse status
+        status_value = metadata.get("status", RunStatus.WIP.value)
+        try:
+            status = RunStatus(status_value)
+        except ValueError:
+            status = RunStatus.from_is_finished_and_exit_code(is_finished, exit_code)
+
+        # Parse start_time from metadata
+        start_time = None
+        start_time_value = metadata.get("start_time")
+        if start_time_value is not None:
+            with contextlib.suppress(ValueError):
+                start_time = parse_to_datetime(start_time_value)
+
+        # Infer stale status
+        status = _infer_stale_status(status, start_time, is_finished)
+
+        # Lightweight corruption check: file exists and is not empty.
+        # Use try/except instead of exists()→stat() to avoid TOCTOU race
+        # when the file is deleted between the two calls (e.g. watcher and
+        # delete API running concurrently).
+        is_corrupted = False
+        error_message = None
+        last_update = None
+
+        run_exists = False
+        run_size = 0
+        try:
+            run_stat = run_file.stat()
+            run_exists = True
+            run_size = run_stat.st_size
+            last_update = datetime.fromtimestamp(run_stat.st_mtime, tz=timezone.utc)
+        except FileNotFoundError:
+            pass
+
+        metadata_exists = metadata_file.exists()
+
+        if not run_exists and not metadata_exists:
+            is_corrupted = True
+            error_message = "Run file not found"
+        elif run_exists and run_size == 0 and not metadata_exists:
+            is_corrupted = True
+            error_message = "Empty file! No data found!"
+
+        return RunInfo(
+            name=run_name,
+            run_id=run_id,
+            start_time=start_time,
+            last_update=last_update,
+            param_count=params_count,
+            artifact_count=0,
+            tags=tags,
+            is_corrupted=is_corrupted,
+            error_message=error_message,
+            is_finished=is_finished,
+            exit_code=exit_code,
+            status=status,
+        )
+
+    def get_runs(self, project: str) -> list[RunInfo]:
+        """List all runs in a project.
+
+        Args:
+            project: Project name
+
+        Returns:
+            List of RunInfo objects sorted by name
+
+        Raises:
+            ValueError: If project name is invalid
+            ProjectNotFoundError: If project does not exist
+        """
+        validate_name(project, "project name")
+
+        project_dir = self.data_dir / project
+        validate_safe_path(project_dir, self.data_dir)
+
+        if not project_dir.exists():
+            raise ProjectNotFoundError(f"Project '{project}' not found")
+
+        runs = []
+        seen_run_names: set[str] = set()
+
+        # Process .jsonl files (including .wal.jsonl for Polars backend).
+        # Iterate the glob generator directly without list() to avoid
+        # materialising all paths upfront. TOCTOU races (file deleted
+        # between discovery and read) are handled by _read_run_info,
+        # which catches FileNotFoundError on stat().
+        for run_file in project_dir.glob("*.jsonl"):
+            # Determine run name from file
+            if run_file.name.endswith(".wal.jsonl"):
+                # Skip WAL files - they're handled by metadata
+                continue
+            else:
+                run_name = run_file.stem
+
+            # Skip if we've already processed this run
+            if run_name in seen_run_names:
+                continue
+            seen_run_names.add(run_name)
+
+            # Handle plain JSONL files
+            run = self._read_run_info(project, run_name, run_file)
+            runs.append(run)
+
+        return sorted(runs, key=lambda r: r.name)
+
+    def get(self, project: str, run: str) -> RunInfo:
+        """Get a specific run.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            RunInfo object
+
+        Raises:
+            ValueError: If project or run name is invalid
+            ProjectNotFoundError: If project does not exist
+            RunNotFoundError: If run does not exist
+        """
+        validate_name(project, "project name")
+        validate_name(run, "run name")
+
+        project_dir = self.data_dir / project
+        validate_safe_path(project_dir, self.data_dir)
+
+        if not project_dir.exists():
+            raise ProjectNotFoundError(f"Project '{project}' not found")
+
+        # Check for JSONL file
+        jsonl_file = project_dir / f"{run}.jsonl"
+
+        if jsonl_file.exists():
+            return self._read_run_info(project, run, jsonl_file)
+        else:
+            raise RunNotFoundError(f"Run '{run}' not found in project '{project}'")
+
+    def delete(self, project: str, run: str) -> None:
+        """Delete a run and its artifacts.
+
+        Args:
+            project: Project name
+            run: Run name to delete
+
+        Raises:
+            ValueError: If project or run name is empty or invalid
+            ProjectNotFoundError: If project does not exist
+            RunNotFoundError: If run does not exist
+            PermissionError: If deletion is not permitted
+        """
+        if not project:
+            raise ValueError("Project name cannot be empty")
+        if not run:
+            raise ValueError("Run name cannot be empty")
+
+        validate_name(project, "project name")
+        validate_name(run, "run name")
+
+        project_dir = self.data_dir / project
+        validate_safe_path(project_dir, self.data_dir)
+
+        if not project_dir.exists():
+            raise ProjectNotFoundError(f"Project '{project}' does not exist")
+
+        # Check for any run files
+        wal_file = project_dir / f"{run}.wal.jsonl"
+        jsonl_file = project_dir / f"{run}.jsonl"
+
+        if not wal_file.exists() and not jsonl_file.exists():
+            raise RunNotFoundError(f"Run '{run}' does not exist in project '{project}'")
+
+        try:
+            # Delete all run-related files
+            metadata_file = project_dir / f"{run}.meta.json"
+            for file_path in [wal_file, jsonl_file, metadata_file]:
+                if file_path.exists():
+                    file_path.unlink()
+                    logger.debug(f"Deleted file: {file_path}")
+
+            # Delete artifacts directory if it exists
+            artifacts_dir = project_dir / run / "artifacts"
+            run_dir = project_dir / run
+
+            if artifacts_dir.exists():
+                shutil.rmtree(artifacts_dir)
+                logger.debug(f"Deleted artifacts for {project}/{run}")
+
+            # Delete run directory if it exists and is empty
+            if run_dir.exists():
+                try:
+                    run_dir.rmdir()
+                    logger.debug(f"Deleted run directory for {project}/{run}")
+                except OSError:
+                    pass
+
+            logger.info(f"Successfully deleted run: {project}/{run}")
+        except (PermissionError, OSError) as e:
+            logger.error(f"Error deleting run {project}/{run}: {type(e).__name__}")
+            raise
+
+    def exists(self, project: str, run: str) -> bool:
+        """Check if a run exists.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            True if run exists, False otherwise
+        """
+        try:
+            validate_name(project, "project name")
+            validate_name(run, "run name")
+
+            project_dir = self.data_dir / project
+            validate_safe_path(project_dir, self.data_dir)
+
+            wal_file = project_dir / f"{run}.wal.jsonl"
+            jsonl_file = project_dir / f"{run}.jsonl"
+
+            return wal_file.exists() or jsonl_file.exists()
+        except ValueError:
+            return False
+
+    async def subscribe(
+        self,
+        targets: Mapping[str, list[str] | None],
+        since: datetime,
+    ) -> AsyncGenerator[MetricRecord | StatusRecord, None]:
+        """Subscribe to file changes for specified targets using DataDirWatcher.
+
+        This method uses a singleton DataDirWatcher instance to minimize inotify
+        file descriptor usage. Multiple SSE connections share the same watcher.
+
+        Args:
+            targets: Dictionary mapping project names to list of run names.
+                     If run list is None, all runs in the project are watched.
+            since: Filter to only yield records with timestamp >= since
+
+        Yields:
+            MetricRecord or StatusRecord as files are updated
+        """
+        from aspara.catalog.watcher import DataDirWatcher
+
+        watcher = await DataDirWatcher.get_instance(self.data_dir)
+        async for record in watcher.subscribe(targets, since):
+            yield record
+
+    def get_artifacts(self, project: str, run: str) -> list[dict]:
+        """Get artifacts for a run from metadata file.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            List of artifact dictionaries
+        """
+        validate_name(project, "project name")
+        validate_name(run, "run name")
+
+        # Read from metadata file
+        metadata_file = self.data_dir / project / f"{run}.meta.json"
+        validate_safe_path(metadata_file, self.data_dir)
+
+        if metadata_file.exists():
+            try:
+                with open(metadata_file) as f:
+                    metadata = json.load(f)
+                    return metadata.get("artifacts", [])
+            except Exception as e:
+                logger.warning(f"Error reading artifacts from metadata file for {run}: {e}")
+
+        return []
+
+    def get_metadata(self, project: str, run: str) -> dict:
+        """Get run metadata from .meta.json file.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            Dictionary containing run metadata
+        """
+        storage = RunMetadataStorage(self.data_dir, project, run)
+        return storage.get_metadata()
+
+    def update_metadata(self, project: str, run: str, metadata: dict) -> dict:
+        """Update run metadata in .meta.json file.
+
+        Args:
+            project: Project name
+            run: Run name
+            metadata: Dictionary with fields to update (notes, tags)
+
+        Returns:
+            Updated complete metadata dictionary
+        """
+        storage = RunMetadataStorage(self.data_dir, project, run)
+        return storage.update_metadata(metadata)
+
+    def delete_metadata(self, project: str, run: str) -> bool:
+        """Delete run metadata file.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            True if file was deleted, False if it didn't exist
+        """
+        storage = RunMetadataStorage(self.data_dir, project, run)
+        return storage.delete_metadata()
+
+    def _guess_artifact_category(self, filename: str) -> str:
+        """Guess artifact category from file extension.
+
+        Args:
+            filename: Name of the artifact file
+
+        Returns:
+            Category string
+        """
+        ext = filename.lower().split(".")[-1] if "." in filename else ""
+
+        if ext in ["py", "js", "ts", "jsx", "tsx", "cpp", "c", "h", "java", "go", "rs", "rb", "php"]:
+            return "code"
+        if ext in ["yaml", "yml", "json", "toml", "ini", "cfg", "conf", "env"]:
+            return "config"
+        if ext in ["pt", "pth", "pkl", "pickle", "h5", "hdf5", "onnx", "pb", "tflite", "joblib"]:
+            return "model"
+        if ext in ["csv", "tsv", "parquet", "feather", "xlsx", "xls", "hdf", "npy", "npz"]:
+            return "data"
+
+        return "other"
+
+    def load_metrics(
+        self,
+        project: str,
+        run: str,
+        start_time: datetime | None = None,
+    ) -> pl.DataFrame:
+        """Load metrics for a run in wide format (auto-detects storage backend).
+
+        Args:
+            project: Project name
+            run: Run name
+            start_time: Optional start time to filter metrics from
+
+        Returns:
+            Polars DataFrame in wide format with columns:
+            - timestamp: Datetime
+            - step: Int64
+            - _<metric_name>: Float64 for each metric (underscore-prefixed)
+
+        Raises:
+            ValueError: If project or run name is invalid
+            RunNotFoundError: If run does not exist
+        """
+        validate_name(project, "project name")
+        validate_name(run, "run name")
+
+        # Create storage using factory function and load metrics
+        storage = _open_metrics_storage(self.data_dir, project, run)
+
+        try:
+            df = storage.load()
+        except Exception as e:
+            logger.warning(f"Failed to load metrics for {project}/{run}: {e}")
+            return pl.DataFrame(
+                schema={
+                    "timestamp": pl.Datetime,
+                    "step": pl.Int64,
+                }
+            )
+
+        # Apply start_time filter if specified
+        if start_time is not None and len(df) > 0:
+            df = df.filter(pl.col("timestamp") >= start_time)
+
+        return df
+
+    def get_run_config(self, project: str, run: str) -> dict[str, Any]:
+        """Get run config from .meta.json file.
+
+        This reads the .meta.json file which contains params, config, status, etc.
+        Different from get_metadata which uses ProjectMetadataStorage for notes/tags.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            Dictionary containing run config (params, config, status, etc.)
+        """
+        validate_name(project, "project name")
+        validate_name(run, "run name")
+
+        metadata_file = self.data_dir / project / f"{run}.meta.json"
+        validate_safe_path(metadata_file, self.data_dir)
+
+        return _read_metadata_file(metadata_file)
+
+    async def get_run_config_async(self, project: str, run: str) -> dict[str, Any]:
+        """Get run config asynchronously using run_in_executor.
+
+        This reads the .meta.json file which contains params, config, status, etc.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            Dictionary containing run config (params, config, status, etc.)
+        """
+        return await asyncio.to_thread(self.get_run_config, project, run)
+
+    async def get_metadata_async(self, project: str, run: str) -> dict[str, Any]:
+        """Get run metadata asynchronously using run_in_executor.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            Dictionary containing run metadata (tags, notes, params, etc.)
+        """
+        return await asyncio.to_thread(self.get_metadata, project, run)
+
+    async def get_artifacts_async(self, project: str, run: str) -> list[dict[str, Any]]:
+        """Get artifacts for a run asynchronously using run_in_executor.
+
+        Args:
+            project: Project name
+            run: Run name
+
+        Returns:
+            List of artifact dictionaries
+        """
+        return await asyncio.to_thread(self.get_artifacts, project, run)

src/aspara/catalog/watcher.py

@@ -0,0 +1,558 @@
+"""
+DataDirWatcher - Singleton watcher for data directory.
+
+This module provides a centralized file watcher service that uses a single
+inotify watcher for the entire data directory. Multiple SSE connections
+subscribe to this service, reducing inotify file descriptor usage.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+import uuid
+from collections.abc import AsyncGenerator, Mapping
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from watchfiles import awatch
+
+from aspara.models import MetricRecord, RunStatus, StatusRecord
+from aspara.utils.timestamp import parse_to_datetime
+from aspara.utils.validators import validate_name
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Subscription:
+    """Subscription to data directory changes."""
+
+    id: str
+    targets: Mapping[str, list[str] | None]  # project -> runs (None means all runs)
+    since: datetime
+    queue: asyncio.Queue[MetricRecord | StatusRecord | None] = field(default_factory=asyncio.Queue)
+
+
+class DataDirWatcher:
+    """Singleton watcher for data directory.
+
+    This class provides a single inotify watcher for the entire data directory,
+    allowing multiple SSE connections to subscribe without consuming additional
+    file descriptors.
+    """
+
+    # Size thresholds for initial read strategy
+    LARGE_FILE_THRESHOLD = 1 * 1024 * 1024  # 1MB
+    TAIL_READ_SIZE = 64 * 1024  # Read last 64KB for large files
+
+    _instance: DataDirWatcher | None = None
+    _lock: asyncio.Lock | None = None
+
+    def __init__(self, data_dir: Path) -> None:
+        """Initialize the watcher.
+
+        Note: Use get_instance() to get the singleton instance.
+
+        Args:
+            data_dir: Base directory for data storage
+        """
+        # Resolve to absolute path for consistent comparison with awatch paths
+        self.data_dir = data_dir.resolve()
+        self._subscriptions: dict[str, Subscription] = {}
+        self._task: asyncio.Task[None] | None = None
+        self._instance_lock = asyncio.Lock()
+        # Track file sizes for incremental reading
+        self._file_sizes: dict[Path, int] = {}
+        # Track run statuses for change detection
+        self._run_statuses: dict[tuple[str, str], str | None] = {}
+
+    @classmethod
+    async def get_instance(cls, data_dir: Path) -> DataDirWatcher:
+        """Get or create singleton instance.
+
+        Args:
+            data_dir: Base directory for data storage
+
+        Returns:
+            DataDirWatcher singleton instance
+        """
+        if cls._lock is None:
+            cls._lock = asyncio.Lock()
+
+        async with cls._lock:
+            if cls._instance is None:
+                cls._instance = cls(data_dir)
+                logger.info(f"[Watcher] Created singleton DataDirWatcher for {data_dir}")
+            return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        """Reset the singleton instance. Used for testing."""
+        cls._instance = None
+        cls._lock = None
+
+    @classmethod
+    async def shutdown(cls) -> None:
+        """Properly shut down the singleton instance.
+
+        Cancels the running dispatch task (which closes the underlying
+        awatch/inotify file descriptor) and then clears the singleton
+        state via reset_instance(). Call this from the application
+        lifespan shutdown so that a subsequent reload does not reuse a
+        stale watcher — which would leak inotify FDs and deliver
+        duplicate events.
+        """
+        instance = cls._instance
+        if instance is not None and instance._task is not None and not instance._task.done():
+            logger.info("[Watcher] Shutting down dispatch task")
+            instance._task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, asyncio.TimeoutError):
+                await asyncio.wait_for(instance._task, timeout=2.0)
+        cls.reset_instance()
+
+    def _parse_file_path(self, file_path: Path) -> tuple[str, str, str] | None:
+        """Parse file path to extract project, run name, and file type.
+
+        Args:
+            file_path: Absolute path to a file
+
+        Returns:
+            (project, run_name, file_type) where file_type is 'metrics', 'wal', or 'meta'
+            None if path doesn't match expected pattern or names are invalid
+        """
+        try:
+            relative = file_path.relative_to(self.data_dir)
+        except ValueError:
+            return None
+
+        parts = relative.parts
+        if len(parts) != 2:
+            return None
+
+        project = parts[0]
+        filename = parts[1]
+
+        if filename.endswith(".wal.jsonl"):
+            run_name = filename[:-10]
+            file_type = "wal"
+        elif filename.endswith(".meta.json"):
+            run_name = filename[:-10]
+            file_type = "meta"
+        elif filename.endswith(".jsonl"):
+            run_name = filename[:-6]
+            file_type = "metrics"
+        else:
+            return None
+
+        # Validate project and run names so that reserved/hidden directories
+        # (e.g. .queue) or names with path-traversal characters are ignored
+        # at the watcher level rather than dispatched to subscribers and
+        # later rejected by the API layer.
+        try:
+            validate_name(project, "project name")
+            validate_name(run_name, "run name")
+        except ValueError:
+            return None
+
+        return (project, run_name, file_type)
+
+    def _parse_metric_line(self, line: str, project: str, run: str, since: datetime) -> MetricRecord | None:
+        """Parse a JSONL line and return MetricRecord if it passes the since filter.
+
+        Args:
+            line: A single line from a JSONL file
+            project: Project name
+            run: Run name
+            since: Filter timestamp - only records with timestamp >= since are returned
+
+        Returns:
+            MetricRecord if parsing succeeds and passes filter, None otherwise
+        """
+        if not line.strip():
+            return None
+        try:
+            entry = json.loads(line)
+            ts_value = entry.get("timestamp")
+            record_ts = None
+            if ts_value is not None:
+                with contextlib.suppress(ValueError):
+                    record_ts = parse_to_datetime(ts_value)
+            if record_ts is None or record_ts >= since:
+                entry["run"] = run
+                entry["project"] = project
+                return MetricRecord(**entry)
+        except Exception as e:
+            logger.debug(f"[Watcher] Error parsing line: {e}")
+        return None
+
+    def _read_file_with_strategy(self, file_path: Path) -> tuple[str, int]:
+        """Read file content with size-based strategy.
+
+        For large files, only the tail portion is read to improve initial load time.
+
+        Args:
+            file_path: Path to the file to read
+
+        Returns:
+            Tuple of (content, end_position) where end_position is the file position after reading
+        """
+        file_size = file_path.stat().st_size
+
+        if file_size < self.LARGE_FILE_THRESHOLD:
+            with open(file_path) as f:
+                content = f.read()
+                return content, f.tell()
+
+        # Large file: read tail only
+        logger.debug(f"[Watcher] Large file ({file_size} bytes), reading tail: {file_path}")
+        with open(file_path) as f:
+            read_start = max(0, file_size - self.TAIL_READ_SIZE)
+            f.seek(read_start)
+            content = f.read()
+            end_pos = f.tell()
+
+            # Skip partial first line if we didn't start at beginning
+            if read_start > 0:
+                first_newline = content.find("\n")
+                if first_newline != -1:
+                    content = content[first_newline + 1 :]
+
+            return content, end_pos
+
+    def _init_run_status(self, project: str, run: str, meta_file: Path) -> None:
+        """Initialize run status tracking from meta file.
+
+        Args:
+            project: Project name
+            run: Run name
+            meta_file: Path to the metadata file
+        """
+        key = (project, run)
+        if meta_file.exists():
+            try:
+                with open(meta_file) as f:
+                    meta = json.load(f)
+                    self._run_statuses[key] = meta.get("status")
+            except Exception:
+                self._run_statuses[key] = None
+        else:
+            self._run_statuses[key] = None
+
+    def _matches_targets(self, targets: Mapping[str, list[str] | None], project: str, run: str) -> bool:
+        """Check if a project/run matches the subscription targets.
+
+        Args:
+            targets: Subscription targets
+            project: Project name
+            run: Run name
+
+        Returns:
+            True if the project/run matches the targets
+        """
+        if project not in targets:
+            return False
+
+        run_list = targets[project]
+        if run_list is None:
+            # None means watch all runs in the project
+            return True
+
+        return run in run_list
+
+    async def _read_initial_data(
+        self,
+        targets: Mapping[str, list[str] | None],
+        since: datetime,
+    ) -> AsyncGenerator[MetricRecord | StatusRecord, None]:
+        """Read initial data from existing files.
+
+        Args:
+            targets: Dictionary mapping project names to run lists
+            since: Filter to only yield records with timestamp >= since
+
+        Yields:
+            MetricRecord objects from existing files
+        """
+        for project, run_names in targets.items():
+            try:
+                validate_name(project, "project name")
+            except ValueError as e:
+                logger.warning(f"[Watcher] Invalid project name {project}: {e}")
+                continue
+
+            project_dir = self.data_dir / project
+            if not project_dir.exists():
+                logger.warning(f"[Watcher] Project directory does not exist: {project_dir}")
+                continue
+
+            # If run_names is None, discover all runs
+            if run_names is None:
+                actual_runs = []
+                for f in project_dir.glob("*.jsonl"):
+                    if f.name.endswith(".wal.jsonl"):
+                        continue
+                    # Skip symlinks to prevent symlink-based attacks
+                    if f.is_symlink():
+                        logger.warning(f"[Watcher] Skipping symlink: {f}")
+                        continue
+                    actual_runs.append(f.stem)
+                run_names = actual_runs
+
+            for run in run_names:
+                # Check which files exist for this run
+                wal_file = project_dir / f"{run}.wal.jsonl"
+                jsonl_file = project_dir / f"{run}.jsonl"
+                meta_file = project_dir / f"{run}.meta.json"
+
+                # Initialize status tracking
+                self._init_run_status(project, run, meta_file)
+
+                # Read metrics files
+                for file_path in [wal_file, jsonl_file]:
+                    if not file_path.exists():
+                        continue
+
+                    resolved = file_path.resolve()
+
+                    try:
+                        content, end_pos = self._read_file_with_strategy(resolved)
+                        self._file_sizes[resolved] = end_pos
+
+                        for line in content.splitlines():
+                            record = self._parse_metric_line(line, project, run, since)
+                            if record is not None:
+                                yield record
+                    except Exception as e:
+                        logger.warning(f"[Watcher] Error reading {resolved}: {e}")
+                        if resolved.exists():
+                            self._file_sizes[resolved] = resolved.stat().st_size
+
+                # Record meta file size
+                if meta_file.exists():
+                    self._file_sizes[meta_file.resolve()] = meta_file.stat().st_size
+
+    async def _dispatch_loop(self) -> None:
+        """Main loop: watch data_dir and dispatch to subscribers."""
+        logger.info(f"[Watcher] Starting dispatch loop for {self.data_dir}")
+        watcher = None
+
+        try:
+            watcher = awatch(str(self.data_dir))
+            loop_count = 0
+            async for changes in watcher:
+                loop_count += 1
+                if loop_count % 10000 == 0:
+                    logger.warning(f"[Watcher] Loop count: {loop_count}, changes: {len(changes)}")
+                logger.debug(f"[Watcher] Received {len(changes)} change(s)")
+
+                for _change_type, changed_path_str in changes:
+                    raw_path = Path(changed_path_str)
+                    # Skip symlinks to prevent reading files outside data_dir.
+                    # The initial read in _read_initial_data already skips
+                    # symlinks; the dispatch loop must do the same so a
+                    # symlink created after subscription cannot bypass it.
+                    if raw_path.is_symlink():
+                        logger.warning(f"[Watcher] Skipping symlink in dispatch: {raw_path}")
+                        continue
+
+                    changed_path = raw_path.resolve()
+
+                    # Parse file path to get project/run/type
+                    parsed = self._parse_file_path(changed_path)
+                    if parsed is None:
+                        continue
+
+                    project, run, file_type = parsed
+                    logger.debug(f"[Watcher] File change: {changed_path} (project={project}, run={run}, type={file_type})")
+
+                    # Dispatch to matching subscribers
+                    async with self._instance_lock:
+                        for sub in self._subscriptions.values():
+                            if not self._matches_targets(sub.targets, project, run):
+                                continue
+
+                            try:
+                                if file_type == "meta":
+                                    # Handle metadata/status update
+                                    status_record = await self._process_meta_change(changed_path, project, run)
+                                    if status_record:
+                                        await sub.queue.put(status_record)
+                                else:
+                                    # Handle metrics update
+                                    metric_records = await self._process_metrics_change(changed_path, project, run, sub.since)
+                                    for metric_record in metric_records:
+                                        await sub.queue.put(metric_record)
+                            except Exception as e:
+                                logger.error(f"[Watcher] Error dispatching to subscription: {e}")
+
+        except asyncio.CancelledError:
+            logger.info("[Watcher] Dispatch loop cancelled")
+            raise
+        except Exception as e:
+            logger.error(f"[Watcher] Error in dispatch loop: {e}")
+        finally:
+            if watcher is not None:
+                logger.info("[Watcher] Closing awatch instance")
+                try:
+                    await asyncio.wait_for(watcher.aclose(), timeout=2.0)
+                except asyncio.TimeoutError:
+                    logger.warning("[Watcher] Timeout closing awatch instance")
+                except Exception as e:
+                    logger.error(f"[Watcher] Error closing watcher: {e}")
+
+    async def _process_meta_change(self, file_path: Path, project: str, run: str) -> StatusRecord | None:
+        """Process a metadata file change.
+
+        Args:
+            file_path: Path to the metadata file
+            project: Project name
+            run: Run name
+
+        Returns:
+            StatusRecord if status changed, None otherwise
+        """
+        try:
+            with open(file_path) as f:
+                meta = json.load(f)
+                new_status = meta.get("status")
+
+                key = (project, run)
+                if new_status != self._run_statuses.get(key):
+                    logger.info(f"[Watcher] Status change for {project}/{run}: {self._run_statuses.get(key)} -> {new_status}")
+                    self._run_statuses[key] = new_status
+
+                    return StatusRecord(
+                        run=run,
+                        project=project,
+                        status=new_status or RunStatus.WIP.value,
+                        is_finished=meta.get("is_finished", False),
+                        exit_code=meta.get("exit_code"),
+                    )
+        except Exception as e:
+            logger.error(f"[Watcher] Error reading metadata file {file_path}: {e}")
+
+        return None
+
+    async def _process_metrics_change(self, file_path: Path, project: str, run: str, since: datetime) -> list[MetricRecord]:
+        """Process a metrics file change.
+
+        Args:
+            file_path: Path to the metrics file
+            project: Project name
+            run: Run name
+            since: Filter timestamp
+
+        Returns:
+            List of MetricRecord objects
+        """
+        records: list[MetricRecord] = []
+
+        try:
+            # Determine where to resume reading. The tracked size may be stale
+            # if the file was truncated (e.g. PolarsMetricsStorage._clear_wal
+            # truncates the WAL to 0 bytes after archiving) or replaced. When
+            # the actual size is smaller than what we last read, rewind to the
+            # beginning so the newly appended content is not silently skipped.
+            actual_size = file_path.stat().st_size
+            tracked_size = self._file_sizes.get(file_path, 0)
+            read_from = 0 if actual_size < tracked_size else tracked_size
+
+            with open(file_path) as f:
+                f.seek(read_from)
+                new_content = f.read()
+                self._file_sizes[file_path] = f.tell()
+
+            for line in new_content.splitlines():
+                record = self._parse_metric_line(line, project, run, since)
+                if record is not None:
+                    records.append(record)
+
+        except Exception as e:
+            logger.error(f"[Watcher] Error processing metrics file {file_path}: {e}")
+
+        return records
+
+    async def subscribe(
+        self,
+        targets: Mapping[str, list[str] | None],
+        since: datetime,
+    ) -> AsyncGenerator[MetricRecord | StatusRecord, None]:
+        """Subscribe to file changes for specified targets.
+
+        Args:
+            targets: Dictionary mapping project names to list of run names.
+                     If run list is None, all runs in the project are watched.
+            since: Filter to only yield records with timestamp >= since
+
+        Yields:
+            MetricRecord or StatusRecord as files are updated
+        """
+        # Ensure since is timezone-aware
+        if since.tzinfo is None:
+            since = since.replace(tzinfo=timezone.utc)
+
+        subscription_id = str(uuid.uuid4())
+        queue: asyncio.Queue[MetricRecord | StatusRecord | None] = asyncio.Queue()
+
+        subscription = Subscription(
+            id=subscription_id,
+            targets=targets,
+            since=since,
+            queue=queue,
+        )
+
+        logger.info(f"[Watcher] New subscription {subscription_id} for targets={targets}")
+
+        async with self._instance_lock:
+            self._subscriptions[subscription_id] = subscription
+            # Start watcher task if not running
+            if self._task is None or self._task.done():
+                logger.info("[Watcher] Starting dispatch task")
+                self._task = asyncio.create_task(self._dispatch_loop())
+
+        try:
+            # Yield initial data (existing records >= since)
+            async for record in self._read_initial_data(targets, since):
+                yield record
+
+            # Yield updates from queue
+            while True:
+                queued_record: MetricRecord | StatusRecord | None = await queue.get()
+                if queued_record is None:  # Sentinel for unsubscribe
+                    break
+                yield queued_record
+        finally:
+            await self._unsubscribe(subscription_id)
+
+    async def _unsubscribe(self, subscription_id: str) -> None:
+        """Unsubscribe from file changes.
+
+        Args:
+            subscription_id: Subscription ID to remove
+        """
+        logger.info(f"[Watcher] Unsubscribing {subscription_id}")
+
+        async with self._instance_lock:
+            if subscription_id in self._subscriptions:
+                del self._subscriptions[subscription_id]
+
+            # Stop watcher task if no more subscribers
+            if not self._subscriptions and self._task is not None:
+                logger.info("[Watcher] No more subscribers, stopping dispatch task")
+                self._task.cancel()
+                try:
+                    await asyncio.wait_for(self._task, timeout=2.0)
+                except asyncio.TimeoutError:
+                    logger.warning("[Watcher] Timeout waiting for dispatch task to finish")
+                except asyncio.CancelledError:
+                    pass
+                self._task = None
+
+    @property
+    def subscription_count(self) -> int:
+        """Get the number of active subscriptions."""
+        return len(self._subscriptions)

src/aspara/cli.py

@@ -0,0 +1,568 @@
+#!/usr/bin/env python3
+"""
+Aspara CLI tool
+
+Command line interface for starting dashboard and tracker API
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import socket
+import sys
+import tempfile
+from importlib.metadata import version as _pkg_version
+from pathlib import Path
+
+import uvicorn
+
+from aspara.config import _validate_data_dir, get_data_dir, get_storage_backend
+
+
+def _get_version() -> str:
+    """Get the installed aspara version.
+
+    Reads package metadata (sourced from pyproject.toml) so the CLI does not
+    need to import the aspara package (and its heavy dependencies) just to
+    print ``--version``.
+    """
+    try:
+        return _pkg_version("aspara")
+    except Exception:
+        # Fallback for environments without installed metadata (e.g. running
+        # directly from a source checkout without install).
+        from aspara import __version__
+
+        return __version__
+
+
+def _resolve_and_validate_data_dir(data_dir: str | None, *, require_writable: bool = True) -> str:
+    """Resolve *data_dir* to an absolute path and validate it.
+
+    Performs the following checks (in order):
+
+    1.  Forbidden system-path check (delegates to ``config._validate_data_dir``).
+    2.  Parent directory exists (so the path is creatable).
+    3.  If *require_writable* is ``True``, the directory (or its parent when
+        it does not yet exist) is writable.
+
+    On any failure an error message is printed to stdout and ``sys.exit(1)``
+    is called.
+
+    Args:
+        data_dir: Raw ``--data-dir`` value. ``None`` falls back to
+            ``get_data_dir()``.
+        require_writable: When ``True`` (server commands), verify write
+            access. Read-only commands (``projects``, ``runs``) pass
+            ``False``.
+
+    Returns:
+        The resolved absolute path as a ``str``.
+    """
+    if data_dir is None:
+        return str(get_data_dir())
+
+    raw_path = Path(data_dir).expanduser()
+    resolved = raw_path.resolve()
+
+    # 1. Forbidden system-path check
+    try:
+        _validate_data_dir(resolved)
+    except ValueError as exc:
+        print(f"Error: {exc}")
+        sys.exit(1)
+
+    # 2. Parent directory must exist (so the path is creatable)
+    parent = resolved if resolved.exists() else resolved.parent
+    if not parent.exists():
+        print(f"Error: data directory parent does not exist: {parent}")
+        print("Hint: create the parent directory first, e.g.:")
+        print(f"  mkdir -p {parent}")
+        sys.exit(1)
+
+    # 3. Writable check (for server commands that write data)
+    if require_writable:
+        test_dir = resolved if resolved.exists() else parent
+        try:
+            with tempfile.TemporaryFile(dir=str(test_dir), prefix=".aspara_write_test_"):
+                pass
+        except (PermissionError, OSError) as exc:
+            print(f"Error: data directory is not writable: {test_dir}")
+            print(f"  {exc}")
+            sys.exit(1)
+
+    return str(resolved)
+
+
+def parse_serve_components(components: list[str]) -> tuple[bool, bool]:
+    """
+    Parse and validate component list for serve command
+
+    Args:
+        components: List of component names
+
+    Returns:
+        Tuple of (enable_dashboard, enable_tracker)
+
+    Raises:
+        ValueError: If invalid component name is provided
+    """
+    valid_components = {"dashboard", "tracker", "together"}
+
+    # Default: dashboard only
+    if not components:
+        return (True, False)
+
+    # Normalize and validate
+    normalized = [c.lower() for c in components]
+    for comp in normalized:
+        if comp not in valid_components:
+            raise ValueError(f"Invalid component: {comp}. Valid options are: dashboard, tracker, together")
+
+    # Handle 'together' keyword
+    if "together" in normalized:
+        return (True, True)
+
+    # Handle explicit component list
+    enable_dashboard = "dashboard" in normalized
+    enable_tracker = "tracker" in normalized
+
+    # If both specified, enable both
+    if enable_dashboard and enable_tracker:
+        return (True, True)
+
+    return (enable_dashboard, enable_tracker)
+
+
+def get_default_port(enable_dashboard: bool, enable_tracker: bool) -> int:
+    """
+    Get default port based on enabled components
+
+    Args:
+        enable_dashboard: Whether dashboard is enabled
+        enable_tracker: Whether tracker is enabled
+
+    Returns:
+        Default port number (3142 for tracker-only, 3141 otherwise)
+    """
+    if enable_tracker and not enable_dashboard:
+        return 3142
+    return 3141
+
+
+def find_available_port(start_port: int = 3141, max_attempts: int = 100) -> int | None:
+    """
+    Find an available port number
+
+    Args:
+        start_port: Starting port number
+        max_attempts: Maximum number of attempts
+
+    Returns:
+        Available port number, None if not found
+    """
+    for port in range(start_port, start_port + max_attempts):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            # If connection fails, that port is available
+            result = sock.connect_ex(("127.0.0.1", port))
+            if result != 0:
+                return port
+    return None
+
+
+def _warn_wildcard_host(host: str) -> None:
+    """Warn when binding to a wildcard address without read-only mode.
+
+    Binding to ``0.0.0.0`` or ``::`` exposes the server to the entire
+    network. Since Aspara has no authentication, anyone on the network
+    can read, modify, or delete all data. This helper prints a warning
+    recommending read-only mode in that case.
+
+    Args:
+        host: Host string passed via ``--host``
+    """
+    if host not in ("0.0.0.0", "::", ""):
+        return
+
+    print("WARNING: binding to a wildcard address exposes the server")
+    print("to the entire network. Aspara has no authentication, so")
+    print("anyone on the network can read, modify, or delete all data.")
+    if os.environ.get("ASPARA_READ_ONLY") != "1":
+        print("Consider enabling read-only mode:")
+        print("  ASPARA_READ_ONLY=1 aspara dashboard --host 0.0.0.0")
+    print()
+
+
+def run_dashboard(
+    host: str = "127.0.0.1",
+    port: int = 3141,
+    with_tracker: bool = False,
+    data_dir: str | None = None,
+    dev: bool = False,
+    project_search_mode: str = "realtime",
+) -> None:
+    """
+    Start dashboard server
+
+    Args:
+        host: Host name
+        port: Port number
+        with_tracker: Whether to run integrated tracker in same process
+        data_dir: Data directory for local data
+        dev: Enable development mode with auto-reload
+        project_search_mode: Project search mode on dashboard home (realtime or manual)
+    """
+    # Set env vars for component mounting
+    os.environ["ASPARA_SERVE_DASHBOARD"] = "1"
+    os.environ["ASPARA_SERVE_TRACKER"] = "1" if with_tracker else "0"
+
+    if with_tracker:
+        os.environ["ASPARA_WITH_TRACKER"] = "1"
+
+    if dev:
+        os.environ["ASPARA_DEV_MODE"] = "1"
+
+    data_dir = _resolve_and_validate_data_dir(data_dir, require_writable=True)
+
+    os.environ["ASPARA_DATA_DIR"] = os.path.abspath(data_dir)
+
+    if project_search_mode:
+        os.environ["ASPARA_PROJECT_SEARCH_MODE"] = project_search_mode
+
+    from aspara.dashboard.router import configure_data_dir
+
+    configure_data_dir(data_dir)
+
+    _warn_wildcard_host(host)
+    print("Starting Aspara Dashboard server...")
+    print(f"Access http://{host}:{port} in your browser!")
+    print(f"Data directory: {os.path.abspath(data_dir)}")
+    backend = get_storage_backend() or "jsonl (default)"
+    print(f"Storage backend: {backend}")
+    if dev:
+        print("Development mode: auto-reload enabled")
+
+    try:
+        uvicorn.run("aspara.server:app", host=host, port=port, reload=dev)
+    except ImportError:
+        print("Error: Dashboard functionality is not installed!")
+        print('To install: uv pip install "aspara[dashboard]"')
+        sys.exit(1)
+
+
+def run_tui(data_dir: str | None = None) -> None:
+    """
+    Start TUI dashboard
+
+    Args:
+        data_dir: Data directory. Defaults to XDG-based default (~/.local/share/aspara)
+    """
+    data_dir = _resolve_and_validate_data_dir(data_dir, require_writable=True)
+
+    print("Starting Aspara TUI...")
+    print(f"Data directory: {os.path.abspath(data_dir)}")
+
+    try:
+        from aspara.tui import run_tui as _run_tui
+
+        _run_tui(data_dir=data_dir)
+    except ImportError:
+        print("TUI functionality is not installed!")
+        print('To install: uv pip install "aspara[tui]"')
+        sys.exit(1)
+
+
+def run_tracker(
+    host: str = "127.0.0.1",
+    port: int = 3142,
+    data_dir: str | None = None,
+    dev: bool = False,
+    storage_backend: str | None = None,
+) -> None:
+    """
+    Start tracker API server
+
+    Args:
+        host: Host name
+        port: Port number
+        data_dir: Data directory. Defaults to XDG-based default (~/.local/share/aspara)
+        dev: Enable development mode with auto-reload
+        storage_backend: Metrics storage backend (jsonl or polars)
+    """
+    # Set env vars for backward compatibility
+    os.environ["ASPARA_SERVE_TRACKER"] = "1"
+    os.environ["ASPARA_SERVE_DASHBOARD"] = "0"
+
+    if dev:
+        os.environ["ASPARA_DEV_MODE"] = "1"
+
+    if storage_backend is not None:
+        os.environ["ASPARA_STORAGE_BACKEND"] = storage_backend
+
+    data_dir = _resolve_and_validate_data_dir(data_dir, require_writable=True)
+
+    os.environ["ASPARA_DATA_DIR"] = os.path.abspath(data_dir)
+
+    _warn_wildcard_host(host)
+    print("Starting Aspara Tracker API server...")
+    print(f"Endpoint: http://{host}:{port}/tracker/api/v1")
+    print(f"Data directory: {os.path.abspath(data_dir)}")
+    backend = get_storage_backend() or "jsonl (default)"
+    print(f"Storage backend: {backend}")
+    if dev:
+        print("Development mode: auto-reload enabled")
+
+    try:
+        uvicorn.run("aspara.server:app", host=host, port=port, reload=dev)
+    except ImportError:
+        print("Error: Tracker functionality is not installed!")
+        print('To install: uv pip install "aspara[tracker]"')
+        sys.exit(1)
+
+
+def run_serve(
+    components: list[str],
+    host: str = "127.0.0.1",
+    port: int | None = None,
+    data_dir: str | None = None,
+    dev: bool = False,
+    project_search_mode: str = "realtime",
+    storage_backend: str | None = None,
+) -> None:
+    """
+    Start Aspara server with specified components
+
+    Args:
+        components: List of components to enable (dashboard, tracker, together)
+        host: Host name
+        port: Port number (auto-detected if None)
+        data_dir: Data directory
+        dev: Enable development mode with auto-reload
+        project_search_mode: Project search mode on dashboard home (realtime or manual)
+        storage_backend: Metrics storage backend (jsonl or polars)
+    """
+    try:
+        enable_dashboard, enable_tracker = parse_serve_components(components)
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # Set environment variables for component mounting
+    os.environ["ASPARA_SERVE_DASHBOARD"] = "1" if enable_dashboard else "0"
+    os.environ["ASPARA_SERVE_TRACKER"] = "1" if enable_tracker else "0"
+
+    if dev:
+        os.environ["ASPARA_DEV_MODE"] = "1"
+
+    if storage_backend is not None:
+        os.environ["ASPARA_STORAGE_BACKEND"] = storage_backend
+
+    # Determine port
+    if port is None:
+        port = get_default_port(enable_dashboard, enable_tracker)
+
+    # Configure data directory
+    data_dir = _resolve_and_validate_data_dir(data_dir, require_writable=True)
+
+    os.environ["ASPARA_DATA_DIR"] = os.path.abspath(data_dir)
+
+    # Configure dashboard if enabled
+    if enable_dashboard:
+        if project_search_mode:
+            os.environ["ASPARA_PROJECT_SEARCH_MODE"] = project_search_mode
+
+        from aspara.dashboard.router import configure_data_dir
+
+        configure_data_dir(data_dir)
+
+    # Build component description
+    if enable_dashboard and enable_tracker:
+        component_desc = "Dashboard + Tracker"
+    elif enable_dashboard:
+        component_desc = "Dashboard"
+    else:
+        component_desc = "Tracker"
+
+    _warn_wildcard_host(host)
+    print(f"Starting Aspara {component_desc} server...")
+    print(f"Access http://{host}:{port} in your browser!")
+    print(f"Data directory: {os.path.abspath(data_dir)}")
+    backend = get_storage_backend() or "jsonl (default)"
+    print(f"Storage backend: {backend}")
+    if dev:
+        print("Development mode: auto-reload enabled")
+
+    try:
+        uvicorn.run("aspara.server:app", host=host, port=port, reload=dev)
+    except ImportError as e:
+        print(f"Error: Required functionality is not installed: {e}")
+        sys.exit(1)
+
+
+def _list_projects(data_dir: str | None) -> None:
+    """Print all projects and their run counts."""
+    from aspara.catalog import ProjectCatalog
+
+    resolved_dir = _resolve_and_validate_data_dir(data_dir, require_writable=False)
+    catalog = ProjectCatalog(resolved_dir)
+    projects = catalog.get_projects()
+
+    if not projects:
+        print("No projects found. Use `aspara.init(project=...)` to create one.")
+        return
+
+    # Column widths for alignment
+    name_w = max(len(p.name) for p in projects)
+    print(f"{'PROJECT':<{name_w}}  RUNS  LAST UPDATED")
+    print(f"{'-' * name_w}  ----  ------------")
+    for p in projects:
+        last = p.last_update.strftime("%Y-%m-%d %H:%M") if p.last_update else "N/A"
+        print(f"{p.name:<{name_w}}  {p.run_count:>4}  {last}")
+
+
+def _list_runs(project: str, data_dir: str | None) -> int:
+    """Print all runs in a project.
+
+    Returns 0 on success, 1 if the project does not exist.
+    """
+    from aspara.catalog import ProjectCatalog, RunCatalog
+
+    resolved_dir = _resolve_and_validate_data_dir(data_dir, require_writable=False)
+    project_catalog = ProjectCatalog(resolved_dir)
+    if not project_catalog.exists(project):
+        print(f"Project '{project}' not found in {resolved_dir}")
+        return 1
+
+    run_catalog = RunCatalog(resolved_dir)
+    runs = run_catalog.get_runs(project)
+
+    if not runs:
+        print(f"No runs found in project '{project}'.")
+        return 0
+
+    status_display = {
+        "wip": "Running",
+        "completed": "Completed",
+        "failed": "Failed",
+        "maybe_failed": "Maybe Failed",
+    }
+
+    name_w = max(len(r.name) for r in runs)
+    print(f"{'RUN':<{name_w}}  STATUS     STARTED")
+    print(f"{'-' * name_w}  --------   -------")
+    for r in runs:
+        status = status_display.get(r.status.value, r.status.value)
+        started = r.start_time.strftime("%Y-%m-%d %H:%M") if r.start_time else "N/A"
+        print(f"{r.name:<{name_w}}  {status:<8}   {started}")
+    return 0
+
+
+def main() -> None:
+    """
+    CLI main entry point
+    """
+    parser = argparse.ArgumentParser(description="Aspara management tool. Run a subcommand to start a server or the TUI.")
+    parser.add_argument("--version", action="version", version=f"aspara {_get_version()}")
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Subcommands")
+
+    dashboard_parser = subparsers.add_parser("dashboard", help="Start dashboard server")
+    dashboard_parser.add_argument("--host", default="127.0.0.1", help="Host name (default: 127.0.0.1)")
+    dashboard_parser.add_argument("--port", type=int, default=3141, help="Port number (default: 3141)")
+    dashboard_parser.add_argument("--with-tracker", action="store_true", help="Run dashboard with integrated tracker in same process")
+    dashboard_parser.add_argument("--data-dir", default=None, help="Data directory (default: XDG-based ~/.local/share/aspara)")
+    dashboard_parser.add_argument("--dev", action="store_true", help="Enable development mode with auto-reload")
+    dashboard_parser.add_argument(
+        "--project-search-mode",
+        choices=["realtime", "manual"],
+        default="realtime",
+        help="Project search mode on dashboard home (realtime or manual, default: realtime)",
+    )
+
+    tracker_parser = subparsers.add_parser("tracker", help="Start tracker API server")
+    tracker_parser.add_argument("--host", default="127.0.0.1", help="Host name (default: 127.0.0.1)")
+    tracker_parser.add_argument("--port", type=int, default=3142, help="Port number (default: 3142)")
+    tracker_parser.add_argument("--data-dir", default=None, help="Data directory (default: XDG-based ~/.local/share/aspara)")
+    tracker_parser.add_argument("--dev", action="store_true", help="Enable development mode with auto-reload")
+    tracker_parser.add_argument(
+        "--storage-backend",
+        choices=["jsonl", "polars"],
+        default=None,
+        help="Metrics storage backend (default: jsonl or ASPARA_STORAGE_BACKEND)",
+    )
+
+    tui_parser = subparsers.add_parser("tui", help="Start terminal UI dashboard")
+    tui_parser.add_argument("--data-dir", default=None, help="Data directory (default: XDG-based ~/.local/share/aspara)")
+
+    serve_parser = subparsers.add_parser("serve", help="Start Aspara server")
+    serve_parser.add_argument(
+        "components",
+        nargs="*",
+        default=[],
+        help="Components to run: dashboard, tracker, together (default: dashboard only)",
+    )
+    serve_parser.add_argument("--host", default="127.0.0.1", help="Host name (default: 127.0.0.1)")
+    serve_parser.add_argument("--port", type=int, default=None, help="Port number (default: 3141 for dashboard, 3142 for tracker-only)")
+    serve_parser.add_argument("--data-dir", default=None, help="Data directory (default: XDG-based ~/.local/share/aspara)")
+    serve_parser.add_argument("--dev", action="store_true", help="Enable development mode with auto-reload")
+    serve_parser.add_argument(
+        "--project-search-mode",
+        choices=["realtime", "manual"],
+        default="realtime",
+        help="Project search mode on dashboard home (realtime or manual, default: realtime)",
+    )
+    serve_parser.add_argument(
+        "--storage-backend",
+        choices=["jsonl", "polars"],
+        default=None,
+        help="Metrics storage backend (default: jsonl or ASPARA_STORAGE_BACKEND)",
+    )
+
+    projects_parser = subparsers.add_parser("projects", help="List all projects")
+    projects_parser.add_argument("--data-dir", default=None, help="Data directory (default: XDG-based ~/.local/share/aspara)")
+
+    runs_parser = subparsers.add_parser("runs", help="List runs in a project")
+    runs_parser.add_argument("project", help="Project name")
+    runs_parser.add_argument("--data-dir", default=None, help="Data directory (default: XDG-based ~/.local/share/aspara)")
+
+    args = parser.parse_args()
+
+    if args.command == "dashboard":
+        run_dashboard(
+            host=args.host,
+            port=args.port,
+            with_tracker=args.with_tracker,
+            data_dir=args.data_dir,
+            dev=args.dev,
+            project_search_mode=args.project_search_mode,
+        )
+    elif args.command == "tracker":
+        run_tracker(
+            host=args.host,
+            port=args.port,
+            data_dir=args.data_dir,
+            dev=args.dev,
+            storage_backend=args.storage_backend,
+        )
+    elif args.command == "tui":
+        run_tui(data_dir=args.data_dir)
+    elif args.command == "serve":
+        run_serve(
+            components=args.components,
+            host=args.host,
+            port=args.port,
+            data_dir=args.data_dir,
+            dev=args.dev,
+            project_search_mode=args.project_search_mode,
+            storage_backend=args.storage_backend,
+        )
+    elif args.command == "projects":
+        _list_projects(data_dir=args.data_dir)
+    elif args.command == "runs":
+        exit_code = _list_runs(project=args.project, data_dir=args.data_dir)
+        if exit_code != 0:
+            sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

src/aspara/config.py

@@ -0,0 +1,266 @@
+"""Configuration and environment handling for Aspara."""
+
+import os
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+__all__ = [
+    "ResourceLimits",
+    "SSE_METRICS_ITERATOR_CLOSE_TIMEOUT",
+    "get_data_dir",
+    "get_resource_limits",
+    "get_sse_dev_shutdown_timeout",
+    "get_sse_heartbeat_interval",
+    "get_sse_send_timeout",
+    "get_storage_backend",
+    "get_project_search_mode",
+    "is_dev_mode",
+    "is_read_only",
+]
+
+
+class ResourceLimits(BaseModel):
+    """Resource limits configuration.
+
+    Includes security-related limits (file size, JSONL lines) and
+    performance/resource constraints (metric names, note length, tags count).
+
+    All limits can be customized via environment variables.
+    Defaults are set for internal use with generous limits.
+    """
+
+    max_file_size: int = Field(
+        default=1024 * 1024 * 1024,  # 1024MB (1GB)
+        description="Maximum file size in bytes",
+    )
+
+    max_jsonl_lines: int = Field(
+        default=1_000_000,  # 1M lines
+        description="Maximum number of lines when reading JSONL files",
+    )
+
+    max_zip_size: int = Field(
+        default=1024 * 1024 * 1024,  # 1GB
+        description="Maximum ZIP file size in bytes",
+    )
+
+    max_metric_names: int = Field(
+        default=100,
+        description="Maximum number of metric names in comma-separated list",
+    )
+
+    max_notes_length: int = Field(
+        default=10 * 1024,  # 10KB
+        description="Maximum notes text length in characters",
+    )
+
+    max_tags_count: int = Field(
+        default=100,
+        description="Maximum number of tags",
+    )
+
+    lttb_threshold: int = Field(
+        default=1_000,
+        description="Downsample metrics using LTTB algorithm when metric series length exceeds this threshold",
+    )
+
+    @classmethod
+    def from_env(cls) -> "ResourceLimits":
+        """Create ResourceLimits from environment variables.
+
+        Environment variables:
+        - ASPARA_MAX_FILE_SIZE: Maximum file size in bytes (default: 1GB)
+        - ASPARA_MAX_JSONL_LINES: Maximum JSONL lines (default: 1M)
+        - ASPARA_MAX_ZIP_SIZE: Maximum ZIP size in bytes (default: 1GB)
+        - ASPARA_MAX_METRIC_NAMES: Maximum metric names (default: 100)
+        - ASPARA_MAX_NOTES_LENGTH: Maximum notes length (default: 10KB)
+        - ASPARA_MAX_TAGS_COUNT: Maximum tags count (default: 100)
+        - ASPARA_LTTB_THRESHOLD: Threshold for LTTB downsampling (default: 1000)
+        """
+        return cls(
+            max_file_size=int(os.environ.get("ASPARA_MAX_FILE_SIZE", cls.model_fields["max_file_size"].default)),
+            max_jsonl_lines=int(os.environ.get("ASPARA_MAX_JSONL_LINES", cls.model_fields["max_jsonl_lines"].default)),
+            max_zip_size=int(os.environ.get("ASPARA_MAX_ZIP_SIZE", cls.model_fields["max_zip_size"].default)),
+            max_metric_names=int(os.environ.get("ASPARA_MAX_METRIC_NAMES", cls.model_fields["max_metric_names"].default)),
+            max_notes_length=int(os.environ.get("ASPARA_MAX_NOTES_LENGTH", cls.model_fields["max_notes_length"].default)),
+            max_tags_count=int(os.environ.get("ASPARA_MAX_TAGS_COUNT", cls.model_fields["max_tags_count"].default)),
+            lttb_threshold=int(os.environ.get("ASPARA_LTTB_THRESHOLD", cls.model_fields["lttb_threshold"].default)),
+        )
+
+
+# Global resource limits instance
+_resource_limits: ResourceLimits | None = None
+
+
+def get_resource_limits() -> ResourceLimits:
+    """Get resource limits configuration.
+
+    Returns cached instance if already initialized.
+    """
+    global _resource_limits
+    if _resource_limits is None:
+        _resource_limits = ResourceLimits.from_env()
+    return _resource_limits
+
+
+# Forbidden system directories that cannot be used as data directories
+_FORBIDDEN_PATHS = frozenset(["/", "/etc", "/sys", "/dev", "/bin", "/sbin", "/usr", "/var", "/boot", "/proc"])
+
+
+def _validate_data_dir(data_path: Path) -> None:
+    """Validate that data directory is not a dangerous system path.
+
+    Args:
+        data_path: Path to validate
+
+    Raises:
+        ValueError: If path is a forbidden system directory
+    """
+    resolved = data_path.resolve()
+    resolved_str = str(resolved)
+
+    for forbidden in _FORBIDDEN_PATHS:
+        if resolved_str == forbidden or resolved_str.rstrip("/") == forbidden:
+            raise ValueError(f"ASPARA_DATA_DIR cannot be set to system directory: {forbidden}")
+
+
+def get_data_dir() -> Path:
+    """Get the default data directory for Aspara.
+
+    Resolution priority:
+    1. ASPARA_DATA_DIR environment variable (if set)
+    2. XDG_DATA_HOME/aspara (if XDG_DATA_HOME is set)
+    3. ~/.local/share/aspara (fallback)
+
+    Returns:
+        Path object pointing to the data directory.
+
+    Raises:
+        ValueError: If ASPARA_DATA_DIR points to a system directory
+
+    Examples:
+        >>> # Using ASPARA_DATA_DIR
+        >>> os.environ["ASPARA_DATA_DIR"] = "/custom/path"
+        >>> get_data_dir()
+        Path('/custom/path')
+
+        >>> # Using XDG_DATA_HOME
+        >>> os.environ["XDG_DATA_HOME"] = "/home/user/.local/share"
+        >>> get_data_dir()
+        Path('/home/user/.local/share/aspara')
+
+        >>> # Using fallback
+        >>> get_data_dir()
+        Path('/home/user/.local/share/aspara')
+    """
+    # Priority 1: ASPARA_DATA_DIR environment variable
+    aspara_data_dir = os.environ.get("ASPARA_DATA_DIR")
+    if aspara_data_dir:
+        data_path = Path(aspara_data_dir).expanduser().resolve()
+        _validate_data_dir(data_path)
+        return data_path
+
+    # Priority 2: XDG_DATA_HOME/aspara
+    xdg_data_home = os.environ.get("XDG_DATA_HOME")
+    if xdg_data_home:
+        return Path(xdg_data_home).expanduser() / "aspara"
+
+    # Priority 3: ~/.local/share/aspara (fallback)
+    return Path.home() / ".local" / "share" / "aspara"
+
+
+def get_project_search_mode() -> str:
+    """Get project search mode from environment variable.
+
+    Returns:
+        Project search mode ("realtime" or "manual"). Defaults to "realtime".
+    """
+    mode = os.environ.get("ASPARA_PROJECT_SEARCH_MODE", "realtime")
+    if mode not in ("realtime", "manual"):
+        return "realtime"
+    return mode
+
+
+def get_storage_backend() -> str | None:
+    """Get storage backend from environment variable.
+
+    Returns:
+        Storage backend name if ASPARA_STORAGE_BACKEND is set, None otherwise.
+    """
+    return os.environ.get("ASPARA_STORAGE_BACKEND")
+
+
+def use_lttb_fast() -> bool:
+    """Check if fast LTTB implementation should be used.
+
+    Returns:
+        True if ASPARA_LTTB_FAST is set to "1", False otherwise.
+    """
+    return os.environ.get("ASPARA_LTTB_FAST") == "1"
+
+
+def is_dev_mode() -> bool:
+    """Check if running in development mode.
+
+    Returns:
+        True if ASPARA_DEV_MODE is set to "1", False otherwise.
+    """
+    return os.environ.get("ASPARA_DEV_MODE") == "1"
+
+
+def is_read_only() -> bool:
+    """Check if running in read-only mode.
+
+    Returns:
+        True if ASPARA_READ_ONLY is set to "1", False otherwise.
+    """
+    return os.environ.get("ASPARA_READ_ONLY") == "1"
+
+
+# Default SSE heartbeat interval in seconds.
+# Sent to keep connections alive and detect dead clients.
+_SSE_DEFAULT_HEARTBEAT_INTERVAL = 15
+
+# Default SSE send timeout in seconds.
+# If a client stops reading, the server gives up after this many seconds.
+_SSE_DEFAULT_SEND_TIMEOUT = 30.0
+
+# Timeout for closing the metrics async iterator during SSE cleanup.
+# This is the upper bound for watcher unsubscribe / generator finalization
+# when an SSE connection ends (either client disconnect or server shutdown).
+SSE_METRICS_ITERATOR_CLOSE_TIMEOUT = 1.0
+
+# Timeout for forcefully cancelling active SSE tasks during dev-mode shutdown.
+# Must be >= SSE_METRICS_ITERATOR_CLOSE_TIMEOUT so that each cancelled task
+# has enough time to run its `finally` block (which closes the metrics
+# iterator) before the shutdown gives up. Production shutdown uses a fixed
+# graceful drain instead (see dashboard.main.lifespan).
+_SSE_DEV_SHUTDOWN_TIMEOUT = 2.0
+
+
+def get_sse_heartbeat_interval() -> int:
+    """Get the SSE heartbeat (ping) interval in seconds.
+
+    Environment variable:
+        ASPARA_SSE_HEARTBEAT_INTERVAL: override the ping interval (default: 15)
+    """
+    return int(os.environ.get("ASPARA_SSE_HEARTBEAT_INTERVAL", _SSE_DEFAULT_HEARTBEAT_INTERVAL))
+
+
+def get_sse_send_timeout() -> float:
+    """Get the SSE send timeout in seconds.
+
+    Environment variable:
+        ASPARA_SSE_SEND_TIMEOUT: override the send timeout (default: 30.0)
+    """
+    return float(os.environ.get("ASPARA_SSE_SEND_TIMEOUT", _SSE_DEFAULT_SEND_TIMEOUT))
+
+
+def get_sse_dev_shutdown_timeout() -> float:
+    """Get the SSE task cancellation timeout (seconds) used during dev-mode shutdown.
+
+    Environment variable:
+        ASPARA_SSE_DEV_SHUTDOWN_TIMEOUT: override the timeout (default: 2.0)
+    """
+    return float(os.environ.get("ASPARA_SSE_DEV_SHUTDOWN_TIMEOUT", _SSE_DEV_SHUTDOWN_TIMEOUT))

src/aspara/dashboard/__init__.py

@@ -0,0 +1,5 @@
+"""
+Aspara metrics visualization dashboard package!
+"""
+
+__version__ = "0.1.0"

src/aspara/dashboard/dependencies.py

@@ -0,0 +1,120 @@
+"""
+FastAPI dependency injection for Aspara Dashboard.
+
+This module provides reusable dependencies for:
+- Catalog instance management (ProjectCatalog, RunCatalog)
+- Path parameter validation (project names, run names)
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import Depends, HTTPException
+from fastapi import Path as PathParam
+
+from aspara.catalog import ProjectCatalog, RunCatalog
+from aspara.config import get_data_dir
+from aspara.utils import validators
+
+# Mutable container for custom data directory configuration
+_custom_data_dir: list[str | None] = [None]
+
+
+def _get_catalogs() -> tuple[ProjectCatalog, RunCatalog, Path]:
+    """Get or create catalog instances.
+
+    Returns:
+        Tuple of (ProjectCatalog, RunCatalog, data_dir Path)
+    """
+    if _custom_data_dir[0] is not None:
+        data_dir = Path(_custom_data_dir[0])
+    else:
+        data_dir = Path(get_data_dir())
+    return ProjectCatalog(str(data_dir)), RunCatalog(str(data_dir)), data_dir
+
+
+# Cached version for performance
+@lru_cache(maxsize=1)
+def _get_cached_catalogs() -> tuple[ProjectCatalog, RunCatalog, Path]:
+    """Get cached catalog instances."""
+    return _get_catalogs()
+
+
+def get_project_catalog() -> ProjectCatalog:
+    """Get the ProjectCatalog singleton instance."""
+    return _get_cached_catalogs()[0]
+
+
+def get_run_catalog() -> RunCatalog:
+    """Get the RunCatalog singleton instance."""
+    return _get_cached_catalogs()[1]
+
+
+def get_data_dir_path() -> Path:
+    """Get the data directory path."""
+    return _get_cached_catalogs()[2]
+
+
+def configure_data_dir(data_dir: str | None = None) -> None:
+    """Configure data directory and reinitialize catalogs.
+
+    This function clears the cached catalogs and reinitializes them
+    with the specified data directory.
+
+    Args:
+        data_dir: Custom data directory path. If None, uses default.
+    """
+    # Clear the cache to force reinitialization
+    _get_cached_catalogs.cache_clear()
+
+    # Set custom data directory
+    _custom_data_dir[0] = data_dir
+
+
+def get_validated_project(project: Annotated[str, PathParam(description="Project name")]) -> str:
+    """Validate project name path parameter.
+
+    Args:
+        project: Project name from URL path.
+
+    Returns:
+        Validated project name.
+
+    Raises:
+        HTTPException: 400 if project name is invalid.
+    """
+    try:
+        validators.validate_project_name(project)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from None
+    return project
+
+
+def get_validated_run(run: Annotated[str, PathParam(description="Run name")]) -> str:
+    """Validate run name path parameter.
+
+    Args:
+        run: Run name from URL path.
+
+    Returns:
+        Validated run name.
+
+    Raises:
+        HTTPException: 400 if run name is invalid.
+    """
+    try:
+        validators.validate_run_name(run)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from None
+    return run
+
+
+# Type aliases for dependency injection
+ValidatedProject = Annotated[str, Depends(get_validated_project)]
+ValidatedRun = Annotated[str, Depends(get_validated_run)]
+ProjectCatalogDep = Annotated[ProjectCatalog, Depends(get_project_catalog)]
+RunCatalogDep = Annotated[RunCatalog, Depends(get_run_catalog)]
+DataDirDep = Annotated[Path, Depends(get_data_dir_path)]

src/aspara/dashboard/main.py

@@ -0,0 +1,157 @@
+"""
+FastAPI application for Aspara Dashboard
+"""
+
+import asyncio
+import contextlib
+import logging
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+
+from aspara.catalog import DataDirWatcher
+from aspara.config import get_sse_dev_shutdown_timeout, is_dev_mode
+
+from .router import router
+
+logger = logging.getLogger(__name__)
+
+
+# Global state for SSE connection management
+class AppState:
+    """Application state for managing SSE connections during shutdown."""
+
+    def __init__(self) -> None:
+        self.active_sse_connections: set[asyncio.Queue] = set()
+        self.active_sse_tasks: set[asyncio.Task] = set()
+        self.shutting_down = False
+
+
+app_state = AppState()
+
+
+class SecurityHeadersMiddleware(BaseHTTPMiddleware):
+    """Middleware to add security headers to all responses."""
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        response = await call_next(request)
+
+        # Prevent MIME type sniffing
+        response.headers["X-Content-Type-Options"] = "nosniff"
+
+        # Prevent clickjacking by denying framing
+        response.headers["X-Frame-Options"] = "DENY"
+
+        # Enable XSS filter in browsers (legacy but still useful)
+        response.headers["X-XSS-Protection"] = "1; mode=block"
+
+        # HSTS - set unconditionally because:
+        # - Browsers ignore it on HTTP responses, so HTTP deployments are unaffected
+        # - Browsers ignore it from localhost (Chrome 132+, Firefox, Brave),
+        #   so local development is never locked out
+        # - It only takes effect on HTTPS responses from non-localhost hosts,
+        #   which is exactly the production case (HF Spaces, internal LAN TLS)
+        response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
+
+        # Content Security Policy - basic policy
+        # Allows self-origin scripts/styles, inline styles for chart libraries,
+        # and data: URIs for images (used by chart exports)
+        response.headers["Content-Security-Policy"] = (
+            "default-src 'self'; "
+            "script-src 'self'; "
+            "style-src 'self' 'unsafe-inline'; "
+            "img-src 'self' data:; "
+            "font-src 'self'; "
+            "connect-src 'self'; "
+            "frame-ancestors 'none'"
+        )
+
+        # Allow iframe embedding when ASPARA_ALLOW_IFRAME=1 (e.g., HF Spaces)
+        if os.environ.get("ASPARA_ALLOW_IFRAME") == "1":
+            del response.headers["X-Frame-Options"]
+            response.headers["Content-Security-Policy"] = (
+                "default-src 'self'; "
+                "script-src 'self'; "
+                "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
+                "img-src 'self' data:; "
+                "font-src 'self' https://fonts.gstatic.com; "
+                "connect-src 'self'; "
+                "frame-ancestors https://huggingface.co https://*.hf.space"
+            )
+
+        return response
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage application lifecycle.
+
+    On shutdown, signal all active SSE connections to close gracefully.
+    In development mode, forcefully cancel SSE tasks for fast restart.
+    """
+    # Startup
+    yield
+
+    # Shutdown
+    app_state.shutting_down = True
+
+    # Signal all active SSE connections to stop
+    for queue in list(app_state.active_sse_connections):
+        # Queue might already be closed or event loop shutting down
+        with contextlib.suppress(RuntimeError, OSError):
+            await queue.put(None)  # Sentinel value to signal shutdown
+
+    if is_dev_mode():
+        # Development mode: forcefully cancel SSE tasks for fast restart.
+        # The timeout must be >= SSE_METRICS_ITERATOR_CLOSE_TIMEOUT so each
+        # cancelled task can finish its `finally` cleanup (closing the
+        # metrics iterator / watcher unsubscribe) before we give up.
+        shutdown_timeout = get_sse_dev_shutdown_timeout()
+        logger.info(f"[DEV MODE] Cancelling {len(app_state.active_sse_tasks)} active SSE tasks (timeout={shutdown_timeout}s)")
+        for task in list(app_state.active_sse_tasks):
+            task.cancel()
+
+        # Wait for tasks to be cancelled
+        if app_state.active_sse_tasks:
+            with contextlib.suppress(asyncio.TimeoutError):
+                await asyncio.wait_for(
+                    asyncio.gather(*app_state.active_sse_tasks, return_exceptions=True),
+                    timeout=shutdown_timeout,
+                )
+        logger.info("[DEV MODE] SSE tasks cancelled, shutdown complete")
+    else:
+        # Production mode: graceful shutdown with 30 second timeout
+        await asyncio.sleep(0.5)
+
+    # Tear down the DataDirWatcher singleton so that the underlying
+    # awatch/inotify FD is closed and a subsequent reload (e.g. --dev
+    # auto-reload) does not reuse a stale watcher — which would leak
+    # inotify FDs and deliver duplicate events.
+    await DataDirWatcher.shutdown()
+
+
+app = FastAPI(
+    title="Aspara Dashboard",
+    description="Real-time metrics visualization for machine learning experiments",
+    docs_url="/docs/dashboard" if is_dev_mode() else None,
+    redoc_url=None,
+    lifespan=lifespan,
+)
+
+# Security headers middleware
+app.add_middleware(SecurityHeadersMiddleware)  # ty: ignore[invalid-argument-type]
+
+# No CORS middleware is configured intentionally. The dashboard static JS and API
+# are served from the same origin, so CORS is unnecessary. Keeping a wildcard
+# CORS policy would allow cross-origin sites to pass the X-Requested-With CSRF
+# header check via preflight, defeating that protection.
+
+BASE_DIR = Path(__file__).parent
+app.mount("/static", StaticFiles(directory=BASE_DIR / "static"), name="static")
+
+app.include_router(router)

src/aspara/dashboard/models/__init__.py

@@ -0,0 +1,3 @@
+"""
+Aspara dashboard data model definitions!
+"""

src/aspara/dashboard/models/metrics.py

@@ -0,0 +1,49 @@
+"""
+Models for metrics data.
+
+This module defines the data models for the dashboard API.
+Note: experiment concept has been removed - data structure is now project/run.
+"""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from aspara.catalog.project_catalog import ProjectInfo
+from aspara.catalog.run_catalog import RunInfo
+
+__all__ = [
+    "Metadata",
+    "MetadataUpdateRequest",
+    "MetricSeries",
+    "ProjectInfo",
+    "RunInfo",
+]
+
+
+class Metadata(BaseModel):
+    """Metadata for projects and runs."""
+
+    notes: str = ""
+    tags: list[str] = []
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class MetadataUpdateRequest(BaseModel):
+    """Request model for updating metadata."""
+
+    notes: str | None = None
+    tags: list[str] | None = None
+
+
+class MetricSeries(BaseModel):
+    """A single metric time series with steps, values, and timestamps.
+
+    Used in the metrics API response to represent one metric's data.
+    Arrays are delta-compressed where applicable.
+    """
+
+    steps: list[int | float]
+    values: list[int | float]
+    timestamps: list[int | float]

src/aspara/dashboard/router.py

@@ -0,0 +1,25 @@
+"""
+Aspara Dashboard APIRouter aggregation.
+
+This module aggregates all route handlers from sub-modules:
+- html_routes: HTML page endpoints
+- api_routes: REST API endpoints
+- sse_routes: Server-Sent Events streaming endpoints
+
+Note: experiment concept has been removed - URL structure is now /projects/{project}/runs/{run}
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+# Re-export configure_data_dir for backwards compatibility
+from .dependencies import configure_data_dir
+from .routes import api_router, html_router, sse_router
+
+router = APIRouter()
+router.include_router(html_router)
+router.include_router(api_router)
+router.include_router(sse_router)
+
+__all__ = ["router", "configure_data_dir"]

src/aspara/dashboard/routes/__init__.py

@@ -0,0 +1,14 @@
+"""
+Aspara Dashboard routes.
+
+This package contains route handlers organized by type:
+- html_routes: HTML page endpoints
+- api_routes: REST API endpoints
+- sse_routes: Server-Sent Events streaming endpoints
+"""
+
+from .api_routes import router as api_router
+from .html_routes import router as html_router
+from .sse_routes import router as sse_router
+
+__all__ = ["html_router", "api_router", "sse_router"]

src/aspara/dashboard/routes/api_routes.py

@@ -0,0 +1,458 @@
+"""
+REST API routes for Aspara Dashboard.
+
+This module handles all REST API endpoints:
+- Artifacts download API
+- Bulk metrics API
+- Project/Run metadata APIs
+- Delete APIs
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+import urllib.parse
+import zipfile
+from collections import defaultdict
+from collections.abc import Iterator
+from datetime import datetime, timezone
+from typing import Any
+
+import msgpack
+from fastapi import APIRouter, Depends, Header, HTTPException, Query
+from fastapi.responses import JSONResponse, Response, StreamingResponse
+
+from aspara.config import get_resource_limits, is_read_only
+from aspara.exceptions import ProjectNotFoundError, RunNotFoundError
+from aspara.utils import validators
+
+from ..dependencies import (
+    DataDirDep,
+    ProjectCatalogDep,
+    RunCatalogDep,
+    ValidatedProject,
+    ValidatedRun,
+)
+from ..models.metrics import Metadata, MetadataUpdateRequest
+from ..utils import parse_and_validate_run_list
+from ..utils.compression import compress_metrics
+
+
+async def verify_csrf_header(x_requested_with: str | None = Header(None, alias="X-Requested-With")) -> None:
+    """CSRF protection via custom header check.
+
+    Verifies that requests include the X-Requested-With header, which cannot be set
+    by cross-origin requests without CORS preflight. This prevents CSRF attacks.
+
+    Args:
+        x_requested_with: The X-Requested-With header value
+
+    Raises:
+        HTTPException: 403 if header is missing
+    """
+    if x_requested_with is None:
+        raise HTTPException(status_code=403, detail="Missing X-Requested-With header")
+
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Spool threshold: zips smaller than this stay in memory; larger ones
+# roll over to a temp file on disk. 1 MiB keeps per-request memory
+# bounded while avoiding disk I/O for the common small-artifact case.
+_ZIP_SPOOL_MAX_BYTES = 1 << 20  # 1 MiB
+_ZIP_STREAM_CHUNK_SIZE = 64 * 1024  # 64 KiB
+
+
+def _stream_zip(
+    artifact_entries: list[tuple[str, str, int]],
+) -> Iterator[bytes]:
+    """Build a ZIP on a SpooledTemporaryFile and yield it in chunks.
+
+    The ZIP is written to a ``SpooledTemporaryFile`` (in-memory up to
+    ``_ZIP_SPOOL_MAX_BYTES``, then transparently rolled to a temp file on
+    disk). After the ZIP is finalised the file pointer is rewound and the
+    content is yielded in fixed-size chunks. The temp file is closed in
+    the ``finally`` block so it is cleaned up even on client disconnect.
+
+    Args:
+        artifact_entries: List of (name, path, size) tuples for the
+            files to include in the ZIP.
+
+    Yields:
+        Chunks of the completed ZIP file.
+    """
+    with tempfile.SpooledTemporaryFile(max_size=_ZIP_SPOOL_MAX_BYTES, suffix=".zip") as buf:
+        with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zip_file:
+            for filename, file_path, _ in artifact_entries:
+                zip_file.write(file_path, filename)
+        buf.seek(0)
+        while True:
+            chunk = buf.read(_ZIP_STREAM_CHUNK_SIZE)
+            if not chunk:
+                break
+            yield chunk
+
+
+@router.get("/api/projects/{project}/runs/{run}/artifacts/download")
+async def download_artifacts_zip(
+    project: ValidatedProject,
+    run: ValidatedRun,
+    data_dir: DataDirDep,
+) -> StreamingResponse:
+    """Download all artifacts for a run as a ZIP file.
+
+    Args:
+        project: Project name.
+        run: Run name.
+
+    Returns:
+        StreamingResponse with ZIP file containing all artifacts.
+        Filename format: `{project}_{run}_artifacts_{timestamp}.zip`
+
+    Raises:
+        HTTPException: 400 if project/run name is invalid or total size exceeds limit,
+            404 if no artifacts found.
+    """
+    # Get the artifacts directory path
+    artifacts_dir = data_dir / project / run / "artifacts"
+
+    # Validate path to prevent path traversal
+    try:
+        validators.validate_safe_path(artifacts_dir, data_dir)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid artifacts directory path: {e}") from None
+
+    artifacts_dir_str = str(artifacts_dir)
+
+    if not os.path.exists(artifacts_dir_str):
+        raise HTTPException(status_code=404, detail="No artifacts found for this run")
+
+    # Single-pass: collect file info using scandir (caches stat results).
+    # Use follow_symlinks=False so that symlinks in the artifacts directory
+    # are not followed — this prevents a local attacker from tricking the
+    # ZIP builder into bundling files outside data_dir.
+    artifact_entries: list[tuple[str, str, int]] = []  # (name, path, size)
+    total_size = 0
+
+    with os.scandir(artifacts_dir_str) as entries:
+        for entry in entries:
+            if entry.is_file(follow_symlinks=False):
+                size = entry.stat(follow_symlinks=False).st_size
+                artifact_entries.append((entry.name, entry.path, size))
+                total_size += size
+            elif entry.is_symlink():
+                logger.warning(f"Skipping symlink in artifacts directory: {entry.path}")
+
+    if not artifact_entries:
+        raise HTTPException(status_code=404, detail="No artifact files found")
+
+    # Check total size
+    limits = get_resource_limits()
+    if total_size > limits.max_zip_size:
+        raise HTTPException(
+            status_code=400,
+            detail=(f"Total artifacts size ({total_size} bytes) exceeds maximum ZIP size limit ({limits.max_zip_size} bytes)"),
+        )
+
+    # Generate filename with timestamp
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    zip_filename = f"{project}_{run}_artifacts_{timestamp}.zip"
+
+    # Encode filename for Content-Disposition header to prevent header
+    # injection. Use RFC 5987 encoding for non-ASCII characters.
+    encoded_filename = urllib.parse.quote(zip_filename, safe="")
+
+    # Build the ZIP using a SpooledTemporaryFile so that memory usage is
+    # bounded (small zips stay in memory up to the spool threshold; larger
+    # ones roll over to a temp file on disk). The generator then streams
+    # the file in fixed-size chunks, keeping per-request memory constant
+    # regardless of total ZIP size. The temp file is cleaned up in the
+    # generator's finally block.
+    return StreamingResponse(
+        _stream_zip(artifact_entries),
+        media_type="application/zip",
+        headers={"Content-Disposition": f"attachment; filename*=UTF-8''{encoded_filename}"},
+    )
+
+
+@router.get("/api/projects/{project}/runs/metrics")
+async def runs_metrics_api(
+    project: ValidatedProject,
+    run_catalog: RunCatalogDep,
+    runs: str,
+    format: str = "json",
+    since: int | None = Query(
+        default=None,
+        description="Filter metrics since this UNIX timestamp in milliseconds",
+    ),
+) -> Response:
+    """Get metrics for multiple runs in a single request.
+
+    Useful for comparing metrics across runs. Returns data in metric-first structure
+    where each metric contains data from all requested runs.
+
+    Args:
+        project: Project name.
+        runs: Comma-separated list of run names (e.g., "run1,run2,run3").
+        format: Response format - "json" (default) or "msgpack".
+        since: Optional filter to only return metrics with timestamp >= since (UNIX ms).
+
+    Returns:
+        Response with structure: `{"project": str, "metrics": {metric: {run: {...}}}}`
+        - For "json" format: JSONResponse
+        - For "msgpack" format: Response with application/x-msgpack content type
+
+    Raises:
+        HTTPException: 400 if project name is invalid, format is invalid,
+            or too many runs specified.
+    """
+    # Validate format parameter
+    if format not in ("json", "msgpack"):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid format: {format}. Must be 'json' or 'msgpack'",
+        )
+
+    try:
+        run_list = parse_and_validate_run_list(runs)
+    except ValueError as e:
+        if format == "msgpack":
+            raise HTTPException(status_code=400, detail=str(e)) from None
+        return JSONResponse(content={"error": str(e)}, status_code=400)
+
+    # Convert since (UNIX ms) to datetime if provided
+    # Create timezone-naive datetime (matches DataFrame storage)
+    since_dt = datetime.fromtimestamp(since / 1000, tz=timezone.utc).replace(tzinfo=None) if since is not None else None
+
+    # Load and downsample metrics for all runs in parallel
+    async def load_and_downsample(
+        run_name: str,
+    ) -> tuple[str, dict[str, dict[str, list]] | None]:
+        """Load and downsample metrics for a single run."""
+        try:
+            df = await asyncio.to_thread(run_catalog.load_metrics, project, run_name, since_dt)
+            return (run_name, compress_metrics(df))
+        except Exception as e:
+            logger.warning(f"Failed to load metrics for {project}/{run_name}: {type(e).__name__}: {e}")
+            return (run_name, None)
+
+    # Execute all loads in parallel
+    results = await asyncio.gather(*[load_and_downsample(run_name) for run_name in run_list])
+
+    # Build metrics_by_run from results
+    metrics_by_run: dict[str, dict[str, dict[str, list]]] = {}
+    for run_name, metrics in results:
+        if metrics is not None:
+            metrics_by_run[run_name] = metrics
+
+    # Reorganize to metric-first structure using defaultdict for O(1) key insertion
+    metrics_data: dict[str, dict[str, dict[str, list]]] = defaultdict(dict)
+    for run_name, run_metrics in metrics_by_run.items():
+        for metric_name, metric_arrays in run_metrics.items():
+            metrics_data[metric_name][run_name] = metric_arrays
+
+    response_data = {"project": project, "metrics": metrics_data}
+
+    # Return response based on format
+    if format == "msgpack":
+        # Serialize to MessagePack
+        packed_data = msgpack.packb(response_data, use_single_float=True)
+        return Response(content=packed_data, media_type="application/x-msgpack")
+
+    return JSONResponse(content=response_data)
+
+
+@router.get("/api/projects/{project}/metadata")
+async def get_project_metadata_api(
+    project: ValidatedProject,
+    project_catalog: ProjectCatalogDep,
+) -> Metadata:
+    """Get project metadata.
+
+    Args:
+        project: Project name.
+
+    Returns:
+        Metadata object containing project metadata (tags, notes, etc.).
+
+    Raises:
+        HTTPException: 400 if project name is invalid.
+    """
+    # Use ProjectCatalog metadata API.
+    # Read-only catalog call: offload to a worker thread so the event loop
+    # is not blocked while waiting on file I/O. Write paths
+    # (update_metadata / delete) stay synchronous because they use a
+    # read-modify-write pattern that would race if run concurrently.
+    metadata = await asyncio.to_thread(project_catalog.get_metadata, project)
+    return Metadata.model_validate(metadata)
+
+
+@router.put("/api/projects/{project}/metadata")
+async def update_project_metadata_api(
+    project: ValidatedProject,
+    metadata: MetadataUpdateRequest,
+    project_catalog: ProjectCatalogDep,
+    _csrf: None = Depends(verify_csrf_header),
+) -> Metadata:
+    """Update project metadata.
+
+    Args:
+        project: Project name.
+        metadata: MetadataUpdateRequest containing fields to update.
+
+    Returns:
+        Metadata object containing the updated project metadata.
+
+    Raises:
+        HTTPException: 400 if project name is invalid.
+    """
+    if is_read_only():
+        existing = await asyncio.to_thread(project_catalog.get_metadata, project)
+        return Metadata.model_validate(existing)
+
+    update_data = metadata.model_dump(exclude_none=True)
+
+    # Use ProjectCatalog metadata API
+    updated_metadata = project_catalog.update_metadata(project, update_data)
+    return Metadata.model_validate(updated_metadata)
+
+
+@router.delete("/api/projects/{project}")
+async def delete_project(
+    project: ValidatedProject,
+    project_catalog: ProjectCatalogDep,
+    _csrf: None = Depends(verify_csrf_header),
+) -> Response:
+    """Delete a project and all its runs.
+
+    **Warning**: This operation is irreversible.
+
+    Args:
+        project: Project name.
+
+    Returns:
+        204 No Content on success.
+
+    Raises:
+        HTTPException: 400 if project name is invalid, 403 if permission denied,
+            404 if project not found, 500 for unexpected errors.
+    """
+    if is_read_only():
+        return Response(status_code=204)
+
+    try:
+        project_catalog.delete(project)
+        logger.info(f"Deleted project: {project}")
+        return Response(status_code=204)
+    except ProjectNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e)) from e
+    except PermissionError as e:
+        logger.warning(f"Permission denied deleting project {project}: {e}")
+        raise HTTPException(status_code=403, detail="Permission denied") from e
+    except Exception as e:
+        logger.error(f"Error deleting project {project}: {type(e).__name__}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to delete project") from e
+
+
+@router.get("/api/projects/{project}/runs/{run}/metadata")
+async def get_run_metadata_api(
+    project: ValidatedProject,
+    run: ValidatedRun,
+    run_catalog: RunCatalogDep,
+) -> dict[str, Any]:
+    """Get run metadata.
+
+    Args:
+        project: Project name.
+        run: Run name.
+
+    Returns:
+        Dictionary containing run metadata (tags, notes, params, etc.).
+
+    Raises:
+        HTTPException: 400 if project/run name is invalid.
+    """
+    # Read-only catalog call: offload to a worker thread so the event
+    # loop is not blocked on file I/O. Write paths stay synchronous to
+    # avoid read-modify-write races (see get_project_metadata_api for
+    # the rationale).
+    metadata = await asyncio.to_thread(run_catalog.get_metadata, project, run)
+    return metadata
+
+
+@router.put("/api/projects/{project}/runs/{run}/metadata")
+async def update_run_metadata_api(
+    project: ValidatedProject,
+    run: ValidatedRun,
+    metadata: MetadataUpdateRequest,
+    run_catalog: RunCatalogDep,
+    _csrf: None = Depends(verify_csrf_header),
+) -> dict[str, Any]:
+    """Update run metadata.
+
+    Args:
+        project: Project name.
+        run: Run name.
+        metadata: MetadataUpdateRequest containing fields to update.
+
+    Returns:
+        Dictionary containing the updated run metadata.
+
+    Raises:
+        HTTPException: 400 if project/run name is invalid.
+    """
+    if is_read_only():
+        existing = await asyncio.to_thread(run_catalog.get_metadata, project, run)
+        return existing
+
+    update_data = metadata.model_dump(exclude_none=True)
+
+    # Use RunCatalog metadata API
+    updated_metadata = run_catalog.update_metadata(project, run, update_data)
+    return updated_metadata
+
+
+@router.delete("/api/projects/{project}/runs/{run}")
+async def delete_run(
+    project: ValidatedProject,
+    run: ValidatedRun,
+    run_catalog: RunCatalogDep,
+    _csrf: None = Depends(verify_csrf_header),
+) -> Response:
+    """Delete a run and its artifacts.
+
+    **Warning**: This operation is irreversible.
+
+    Args:
+        project: Project name.
+        run: Run name.
+
+    Returns:
+        204 No Content on success.
+
+    Raises:
+        HTTPException: 400 if project/run name is invalid, 403 if permission denied,
+            404 if project or run not found, 500 for unexpected errors.
+    """
+    if is_read_only():
+        return Response(status_code=204)
+
+    try:
+        run_catalog.delete(project, run)
+        logger.info(f"Deleted run: {project}/{run}")
+        return Response(status_code=204)
+    except ProjectNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e)) from e
+    except RunNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e)) from e
+    except PermissionError as e:
+        logger.warning(f"Permission denied deleting run {project}/{run}: {e}")
+        raise HTTPException(status_code=403, detail="Permission denied") from e
+    except Exception as e:
+        logger.error(f"Error deleting run {project}/{run}: {type(e).__name__}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to delete run") from e

src/aspara/dashboard/routes/html_routes.py

@@ -0,0 +1,327 @@
+"""
+HTML page routes for Aspara Dashboard.
+
+This module handles all HTML page rendering endpoints:
+- Home page (projects list)
+- Project detail page
+- Runs list page
+- Run detail page
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import HTMLResponse
+from starlette.requests import Request
+
+from aspara.config import is_read_only
+from aspara.exceptions import RunNotFoundError
+from aspara.models import RunStatus
+from aspara.utils.timestamp import parse_to_ms
+
+from ..dependencies import (
+    ProjectCatalogDep,
+    RunCatalogDep,
+    ValidatedProject,
+    ValidatedRun,
+)
+from ..services.template_service import (
+    TemplateService,
+    create_breadcrumbs,
+    render_mustache_response,
+)
+
+router = APIRouter()
+
+
+def _format_duration_ms(duration_ms: float | int | None) -> str:
+    """Format a duration given in milliseconds into a human-readable string.
+
+    Returns ``"N/A"`` when no duration is available.
+    """
+    if duration_ms is None or duration_ms < 0:
+        return "N/A"
+    seconds = duration_ms / 1000.0
+    if seconds < 1:
+        return f"{int(duration_ms)}ms"
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    total_seconds = int(seconds)
+    minutes = total_seconds // 60
+    secs = total_seconds % 60
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours = minutes // 60
+    mins = minutes % 60
+    if hours < 24:
+        return f"{hours}h {mins}m"
+    days = hours // 24
+    hrs = hours % 24
+    return f"{days}d {hrs}h"
+
+
+@router.get("/")
+async def home(
+    request: Request,
+    project_catalog: ProjectCatalogDep,
+) -> HTMLResponse:
+    """Render the projects list page."""
+    # Read-only catalog call: offload to worker threads so the event
+    # loop is not blocked on file I/O. Write paths stay synchronous to
+    # avoid read-modify-write races (see api_routes.get_project_metadata_api).
+    # Project metadata is loaded together with the directory scan in one pass
+    # to avoid the N+1 pattern of per-project file opens.
+    projects_with_metadata = await asyncio.to_thread(project_catalog.get_projects_with_metadata)
+
+    formatted_projects = []
+    for project, metadata in projects_with_metadata:
+        tags = metadata.get("tags") or []
+        formatted_projects.append(TemplateService.format_project_for_template(project, tags))
+
+    from aspara.config import get_project_search_mode
+
+    project_search_mode = get_project_search_mode()
+
+    context = {
+        "page_title": "Aspara",
+        "breadcrumbs": create_breadcrumbs([{"label": "Home", "is_home": True}]),
+        "projects": formatted_projects,
+        "has_projects": len(formatted_projects) > 0,
+        "project_search_mode": project_search_mode,
+        "read_only": is_read_only(),
+    }
+
+    html = render_mustache_response("projects_list", context)
+    return HTMLResponse(content=html)
+
+
+@router.get("/projects/{project}")
+async def project_detail(
+    request: Request,
+    project: ValidatedProject,
+    project_catalog: ProjectCatalogDep,
+    run_catalog: RunCatalogDep,
+) -> HTMLResponse:
+    """Project detail page - shows metrics charts."""
+    # Check if project exists
+    if not await asyncio.to_thread(project_catalog.exists, project):
+        raise HTTPException(status_code=404, detail=f"Project '{project}' not found")
+
+    runs = await asyncio.to_thread(run_catalog.get_runs, project)
+
+    # Format runs for template (excluding corrupted runs)
+    formatted_runs = []
+    for run in runs:
+        formatted = TemplateService.format_run_for_project_detail(run)
+        if formatted is not None:
+            formatted_runs.append(formatted)
+
+    # Find the most recent last_update from all runs
+    project_last_update = None
+    if runs:
+        last_updates = [r.last_update for r in runs if r.last_update is not None]
+        if last_updates:
+            project_last_update = max(last_updates)
+
+    context = {
+        "page_title": f"{project} - Metrics",
+        "breadcrumbs": create_breadcrumbs([
+            {"label": "Home", "url": "/", "is_home": True},
+            {"label": project},
+        ]),
+        "project": project,
+        "runs": formatted_runs,
+        "has_runs": len(formatted_runs) > 0,
+        "run_count": len(formatted_runs),
+        "formatted_project_last_update": (project_last_update.strftime("%b %d, %Y at %I:%M %p") if project_last_update else "N/A"),
+        "read_only": is_read_only(),
+    }
+
+    html = render_mustache_response("project_detail", context)
+    return HTMLResponse(content=html)
+
+
+@router.get("/projects/{project}/runs")
+async def list_project_runs(
+    request: Request,
+    project: ValidatedProject,
+    project_catalog: ProjectCatalogDep,
+    run_catalog: RunCatalogDep,
+) -> HTMLResponse:
+    """List runs in a project."""
+    # Check if project exists
+    if not await asyncio.to_thread(project_catalog.exists, project):
+        raise HTTPException(status_code=404, detail=f"Project '{project}' not found")
+
+    runs = await asyncio.to_thread(run_catalog.get_runs, project)
+
+    # Format runs for template
+    formatted_runs = [TemplateService.format_run_for_list(run) for run in runs]
+
+    context = {
+        "page_title": f"{project} - Runs",
+        "breadcrumbs": create_breadcrumbs([
+            {"label": "Home", "url": "/", "is_home": True},
+            {"label": project, "url": f"/projects/{project}"},
+            {"label": "Runs"},
+        ]),
+        "project": project,
+        "runs": formatted_runs,
+        "has_runs": len(formatted_runs) > 0,
+        "read_only": is_read_only(),
+    }
+
+    html = render_mustache_response("runs_list", context)
+    return HTMLResponse(content=html)
+
+
+@router.get("/projects/{project}/runs/{run}")
+async def get_run(
+    request: Request,
+    project: ValidatedProject,
+    run: ValidatedRun,
+    project_catalog: ProjectCatalogDep,
+    run_catalog: RunCatalogDep,
+) -> HTMLResponse:
+    """Get run details including parameters and metrics."""
+    # Check if project exists
+    if not await asyncio.to_thread(project_catalog.exists, project):
+        raise HTTPException(status_code=404, detail=f"Project '{project}' not found")
+
+    # Get Run information and check if it's corrupted
+    try:
+        current_run = await asyncio.to_thread(run_catalog.get, project, run)
+    except RunNotFoundError as e:
+        raise HTTPException(status_code=404, detail=f"Run '{run}' not found in project '{project}'") from e
+
+    is_corrupted = current_run.is_corrupted
+    error_message = current_run.error_message
+    run_tags = current_run.tags
+
+    # Load metrics, artifacts, and metadata in parallel
+    df_metrics, artifacts, metadata = await asyncio.gather(
+        asyncio.to_thread(run_catalog.load_metrics, project, run),
+        run_catalog.get_artifacts_async(project, run),
+        run_catalog.get_run_config_async(project, run),
+    )
+
+    # Extract params from metadata
+    params: dict[str, Any] = {}
+    params.update(metadata.get("params", {}))
+    params.update(metadata.get("config", {}))
+
+    # Format data for template
+    formatted_params = [{"key": k, "value": v} for k, v in params.items()]
+
+    # Get latest metrics for scalar display from wide-format DataFrame
+    latest_metrics: dict[str, Any] = {}
+    if len(df_metrics) > 0:
+        # Get last row (latest metrics)
+        last_row = df_metrics.tail(1).to_dicts()[0]
+        # Extract metric columns (those starting with underscore)
+        for col, value in last_row.items():
+            if col.startswith("_") and value is not None:
+                # Remove underscore prefix
+                metric_name = col[1:]
+                latest_metrics[metric_name] = value
+
+    formatted_latest_metrics = [{"key": k, "value": f"{v:.4f}" if isinstance(v, int | float) else str(v)} for k, v in latest_metrics.items()]
+
+    # Resolve start/finish timestamps (in ms) from metadata. The metadata may
+    # store them as either UNIX milliseconds (real API) or ISO 8601 strings
+    # (legacy/test fixtures), so normalize via parse_to_ms.
+    start_time_raw = metadata.get("start_time")
+    finish_time_raw = metadata.get("finish_time")
+    start_time_ms: int | None = None
+    finish_time_ms: int | None = None
+    if start_time_raw is not None:
+        try:
+            start_time_ms = parse_to_ms(start_time_raw)
+        except ValueError:
+            start_time_ms = None
+    if finish_time_raw is not None:
+        try:
+            finish_time_ms = parse_to_ms(finish_time_raw)
+        except ValueError:
+            finish_time_ms = None
+
+    # Compute duration. For WIP runs (no finish_time), use the most recent
+    # metrics timestamp as the current end so the user sees elapsed time.
+    duration_ms: int | None = None
+    if start_time_ms is not None:
+        end_ms: int | None = finish_time_ms
+        if end_ms is None and len(df_metrics) > 0 and "timestamp" in df_metrics.columns:
+            last_ts = df_metrics.select("timestamp").to_series().max()
+            if isinstance(last_ts, datetime):
+                end_ms = int(last_ts.timestamp() * 1000)
+            elif isinstance(last_ts, (int, float)):
+                end_ms = int(last_ts)
+        if end_ms is not None:
+            duration_ms = end_ms - start_time_ms
+
+    if duration_ms is not None:
+        formatted_duration = _format_duration_ms(duration_ms)
+    elif not is_corrupted and current_run.status == RunStatus.WIP:
+        # WIP run with no metrics yet.
+        formatted_duration = "Running..."
+    else:
+        formatted_duration = "N/A"
+
+    # Step count = number of logged metric rows
+    step_count = len(df_metrics)
+
+    # Start time display: prefer metadata start_time, fall back to DataFrame
+    start_time_display = "N/A"
+    if start_time_ms is not None:
+        try:
+            from aspara.utils.timestamp import parse_to_datetime
+
+            start_time_display = parse_to_datetime(start_time_ms).strftime("%B %d, %Y at %I:%M %p")
+        except ValueError:
+            start_time_display = "N/A"
+    elif len(df_metrics) > 0 and "timestamp" in df_metrics.columns:
+        ts = df_metrics.select("timestamp").to_series().min()
+        if isinstance(ts, datetime):
+            start_time_display = ts.strftime("%B %d, %Y at %I:%M %p")
+
+    # Run status flags for template rendering
+    status = current_run.status
+    status_value = status.value
+
+    context = {
+        "page_title": f"{run} - Details",
+        "breadcrumbs": create_breadcrumbs([
+            {"label": "Home", "url": "/", "is_home": True},
+            {"label": project, "url": f"/projects/{project}"},
+            {"label": "Runs", "url": f"/projects/{project}/runs"},
+            {"label": run},
+        ]),
+        "project": project,
+        "run_name": run,
+        "params": formatted_params,
+        "has_params": len(formatted_params) > 0,
+        "latest_metrics": formatted_latest_metrics,
+        "has_latest_metrics": len(formatted_latest_metrics) > 0,
+        "formatted_start_time": start_time_display,
+        "duration": formatted_duration,
+        "step_count": step_count,
+        "status": status_value,
+        "is_wip": status == RunStatus.WIP,
+        "is_completed": status == RunStatus.COMPLETED,
+        "is_failed": status == RunStatus.FAILED,
+        "is_maybe_failed": status == RunStatus.MAYBE_FAILED,
+        "has_tags": len(run_tags) > 0,
+        "tags": run_tags,
+        "artifacts": [TemplateService.format_artifact_for_template(artifact) for artifact in artifacts],
+        "has_artifacts": len(artifacts) > 0,
+        "is_corrupted": is_corrupted,
+        "error_message": error_message,
+        "read_only": is_read_only(),
+    }
+
+    html = render_mustache_response("run_detail", context)
+    return HTMLResponse(content=html)

src/aspara/dashboard/routes/sse_routes.py

@@ -0,0 +1,226 @@
+"""
+Server-Sent Events (SSE) routes for Aspara Dashboard.
+
+This module handles real-time streaming endpoints:
+- Multiple runs metrics streaming
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Coroutine
+from contextlib import suppress
+from datetime import datetime, timezone
+from typing import Any, cast
+
+from fastapi import APIRouter, Query
+from sse_starlette.sse import EventSourceResponse
+
+from aspara.config import (
+    SSE_METRICS_ITERATOR_CLOSE_TIMEOUT,
+    get_sse_heartbeat_interval,
+    get_sse_send_timeout,
+    is_dev_mode,
+)
+from aspara.models import MetricRecord, StatusRecord
+
+from ..dependencies import RunCatalogDep, ValidatedProject
+from ..utils import parse_and_validate_run_list
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/api/projects/{project}/runs/stream")
+async def stream_multiple_runs(
+    project: ValidatedProject,
+    run_catalog: RunCatalogDep,
+    runs: str,
+    since: int = Query(
+        ...,
+        description="Filter metrics since this UNIX timestamp in milliseconds",
+    ),
+) -> EventSourceResponse:
+    """Stream metrics for multiple runs using Server-Sent Events (SSE).
+
+    Args:
+        project: Project name.
+        runs: Comma-separated list of run names (e.g., "run1,run2,run3").
+        since: Filter to only stream metrics with timestamp >= since (required, UNIX ms).
+
+    Returns:
+        EventSourceResponse streaming metric and status events from all specified runs.
+        Event types:
+        - `metric`: `{"event": "metric", "data": <MetricRecord JSON>}`
+        - `status`: `{"event": "status", "data": <StatusRecord JSON>}`
+
+    Raises:
+        HTTPException: 400 if project/run name is invalid, 422 if since is missing.
+    """
+    logger.info(f"[SSE ENDPOINT] Called with project={project}, runs={runs}")
+
+    from ..main import app_state
+
+    try:
+        run_list = parse_and_validate_run_list(runs)
+    except ValueError as e:
+
+        async def validation_error_generator(msg: str = str(e)):
+            yield {"event": "error", "data": msg}
+
+        return EventSourceResponse(validation_error_generator())
+
+    # Convert UNIX ms to datetime
+    since_dt = datetime.fromtimestamp(since / 1000, tz=timezone.utc)
+
+    async def event_generator():
+        logger.info(f"[SSE] event_generator started for project={project}, runs={run_list}")
+
+        # Register current task for dev mode forced cancellation
+        current_task = asyncio.current_task()
+        if current_task is not None:
+            app_state.active_sse_tasks.add(current_task)
+
+        # Create shutdown queue for this connection
+        shutdown_queue: asyncio.Queue[None] = asyncio.Queue()
+        app_state.active_sse_connections.add(shutdown_queue)
+
+        # Use new subscribe() method with singleton watcher
+        targets = {project: run_list}
+        metrics_iterator = run_catalog.subscribe(targets, since=since_dt).__aiter__()
+        logger.info("[SSE] Created metrics_iterator using subscribe()")
+
+        # In dev mode, use shorter timeout for faster shutdown detection
+        dev_mode = is_dev_mode()
+        wait_timeout = 1.0 if dev_mode else None
+
+        # Track pending metric task to avoid re-creating it after timeout
+        # IMPORTANT: Cancelling a task that's awaiting inside an async generator
+        # will close the generator. We must NOT cancel metric_task on timeout.
+        pending_metric_task: asyncio.Task[MetricRecord | StatusRecord] | None = None
+
+        try:
+            while True:
+                # Check shutdown flag in dev mode
+                if dev_mode and app_state.shutting_down:
+                    logger.info("[SSE] Dev mode: shutdown flag detected")
+                    # Cancel pending metric_task before exiting
+                    if pending_metric_task is not None:
+                        pending_metric_task.cancel()
+                        with suppress(asyncio.CancelledError):
+                            await pending_metric_task
+                    break
+
+                # Create metric_task only if we don't have a pending one
+                if pending_metric_task is None:
+                    metric_coro = cast(
+                        "Coroutine[Any, Any, MetricRecord | StatusRecord]",
+                        metrics_iterator.__anext__(),
+                    )
+                    pending_metric_task = asyncio.create_task(metric_coro, name="metric_task")
+
+                # Always create a new shutdown_task
+                shutdown_coro = cast("Coroutine[Any, Any, Any]", shutdown_queue.get())
+                shutdown_task = asyncio.create_task(shutdown_coro, name="shutdown_task")
+
+                try:
+                    done, pending = await asyncio.wait(
+                        [pending_metric_task, shutdown_task],
+                        return_when=asyncio.FIRST_COMPLETED,
+                        timeout=wait_timeout,
+                    )
+                except asyncio.CancelledError:
+                    # Cancelled by lifespan handler in dev mode
+                    logger.info("[SSE] Task cancelled (dev mode shutdown)")
+                    pending_metric_task.cancel()
+                    shutdown_task.cancel()
+                    with suppress(asyncio.CancelledError):
+                        await pending_metric_task
+                    with suppress(asyncio.CancelledError):
+                        await shutdown_task
+                    raise
+
+                # Handle timeout (dev mode only)
+                if not done:
+                    # Timeout occurred - only cancel shutdown_task, NOT metric_task
+                    # Cancelling metric_task would close the async generator!
+                    shutdown_task.cancel()
+                    with suppress(asyncio.CancelledError):
+                        await shutdown_task
+                    # pending_metric_task is kept and will be reused in next iteration
+                    continue
+
+                logger.debug(f"[SSE] asyncio.wait returned: done={[t.get_name() for t in done]}, pending={[t.get_name() for t in pending]}")
+
+                # Cancel pending tasks (but NOT metric_task if it's pending)
+                if shutdown_task in pending:
+                    shutdown_task.cancel()
+                    with suppress(asyncio.CancelledError):
+                        await shutdown_task
+
+                # Check which task completed
+                if pending_metric_task in done:
+                    # Reset so we create a new task in next iteration
+                    completed_task = pending_metric_task
+                    pending_metric_task = None
+                    try:
+                        record = completed_task.result()
+                        if isinstance(record, MetricRecord):
+                            logger.debug(f"[SSE] Sending metric to client: run={record.run}, step={record.step}")
+                            yield {"event": "metric", "data": record.model_dump_json()}
+                        elif isinstance(record, StatusRecord):
+                            logger.info(f"[SSE] Sending status update to client: run={record.run}, status={record.status}")
+                            yield {"event": "status", "data": record.model_dump_json()}
+                    except StopAsyncIteration:
+                        logger.info("[SSE] No more records (StopAsyncIteration)")
+                        break
+                elif shutdown_task in done:
+                    logger.info("[SSE] Shutdown requested")
+                    # Cancel metric_task since we're shutting down
+                    if pending_metric_task is not None:
+                        pending_metric_task.cancel()
+                        with suppress(asyncio.CancelledError):
+                            await pending_metric_task
+                    break
+
+        except asyncio.CancelledError:
+            logger.info("[SSE] Generator cancelled")
+            raise
+        except Exception as e:
+            # Log the full exception internally. In production, send a generic
+            # message to the client so internal paths, library internals, or
+            # other sensitive details are not leaked over the wire. In dev
+            # mode, include the exception text for easier debugging.
+            logger.error(f"[SSE] Exception in event_generator: {e}", exc_info=True)
+            error_data = str(e) if dev_mode else "Internal server error"
+            yield {"event": "error", "data": error_data}
+        finally:
+            # Clean up: remove this connection from active set
+            logger.info("[SSE] event_generator finished, cleaning up")
+            app_state.active_sse_connections.discard(shutdown_queue)
+            if current_task is not None:
+                app_state.active_sse_tasks.discard(current_task)
+            # Cancel pending metric task if still running
+            if pending_metric_task is not None and not pending_metric_task.done():
+                pending_metric_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await pending_metric_task
+            # Close the async generator to trigger watcher unsubscribe
+            try:
+                await asyncio.wait_for(
+                    metrics_iterator.aclose(),
+                    timeout=SSE_METRICS_ITERATOR_CLOSE_TIMEOUT,
+                )
+            except asyncio.TimeoutError:
+                logger.warning("[SSE] Timeout closing metrics_iterator")
+            except Exception as e:
+                logger.warning(f"[SSE] Error closing metrics_iterator: {e}")
+
+    logger.info(f"[SSE ENDPOINT] Returning EventSourceResponse for runs={run_list}")
+    return EventSourceResponse(
+        event_generator(),
+        ping=get_sse_heartbeat_interval(),
+        send_timeout=get_sse_send_timeout(),
+    )

src/aspara/dashboard/services/__init__.py

@@ -0,0 +1,9 @@
+"""
+Aspara Dashboard services.
+
+This package contains business logic services for the dashboard.
+"""
+
+from .template_service import TemplateService, create_breadcrumbs, render_mustache_response
+
+__all__ = ["TemplateService", "create_breadcrumbs", "render_mustache_response"]

src/aspara/dashboard/services/template_service.py

@@ -0,0 +1,167 @@
+"""
+Template rendering service for Aspara Dashboard.
+
+Provides Mustache template rendering and context formatting utilities.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pystache
+
+from aspara.catalog import ProjectInfo, RunInfo
+from aspara.config import get_resource_limits, is_dev_mode
+
+BASE_DIR = Path(__file__).parent.parent
+_mustache_renderer = pystache.Renderer(search_dirs=[str(BASE_DIR / "templates")])
+
+
+def create_breadcrumbs(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Create standardized breadcrumbs with consistent formatting.
+
+    Args:
+        items: List of breadcrumb items with 'label' and optional 'url' keys.
+              First item is assumed to be Home.
+
+    Returns:
+        List of breadcrumb items with consistent is_not_first flags.
+    """
+    result = []
+
+    for i, item in enumerate(items):
+        crumb = item.copy()
+        crumb["is_not_first"] = i != 0
+
+        # Add home icon to first item if not already specified
+        if i == 0 and "is_home" not in crumb:
+            crumb["is_home"] = True
+
+        result.append(crumb)
+
+    return result
+
+
+def render_mustache_response(template_name: str, context: dict[str, Any]) -> str:
+    """Render mustache template with context.
+
+    Args:
+        template_name: Name of the template file (without extension).
+        context: Template context dictionary.
+
+    Returns:
+        Rendered HTML string.
+    """
+    # Add common context variables
+    context.update({
+        "current_year": datetime.now(timezone.utc).year,
+        "page_title": context.get("page_title", "Aspara"),
+        "dev_mode": is_dev_mode(),
+        # Expose server-side resource limits to the client so the server
+        # remains the single source of truth for validation bounds.
+        "max_notes_length": get_resource_limits().max_notes_length,
+    })
+
+    # Render content template
+    content = _mustache_renderer.render_name(template_name, context)
+
+    # Render layout with content
+    layout_context = context.copy()
+    layout_context["content"] = content
+
+    return _mustache_renderer.render_name("layout", layout_context)
+
+
+class TemplateService:
+    """Service for template rendering and data formatting.
+
+    This class provides methods for formatting data objects for template rendering.
+    """
+
+    @staticmethod
+    def format_project_for_template(project: ProjectInfo, tags: list[str] | None = None) -> dict[str, Any]:
+        """Format a ProjectInfo for template rendering.
+
+        Args:
+            project: ProjectInfo object.
+            tags: Optional list of tags from metadata.
+
+        Returns:
+            Dictionary suitable for template rendering.
+        """
+        return {
+            "name": project.name,
+            "run_count": project.run_count or 0,
+            "last_update": int(project.last_update.timestamp() * 1000) if project.last_update else 0,
+            "formatted_last_update": (project.last_update.strftime("%B %d, %Y at %I:%M %p") if project.last_update else "N/A"),
+            "tags": tags or [],
+        }
+
+    @staticmethod
+    def format_run_for_list(run: RunInfo) -> dict[str, Any]:
+        """Format a RunInfo for runs list template.
+
+        Args:
+            run: RunInfo object.
+
+        Returns:
+            Dictionary suitable for runs list template rendering.
+        """
+        return {
+            "name": run.name,
+            "param_count": run.param_count or 0,
+            "last_update": int(run.last_update.timestamp() * 1000) if run.last_update else 0,
+            "formatted_last_update": (run.last_update.strftime("%B %d, %Y at %I:%M %p") if run.last_update else "N/A"),
+            "is_corrupted": run.is_corrupted,
+            "error_message": run.error_message,
+            "tags": run.tags,
+            "has_tags": len(run.tags) > 0,
+            "is_finished": run.is_finished,
+            "is_wip": run.status.value == "wip",
+            "status": run.status.value,
+        }
+
+    @staticmethod
+    def format_run_for_project_detail(run: RunInfo) -> dict[str, Any] | None:
+        """Format a RunInfo for project detail template (excludes corrupted runs).
+
+        Args:
+            run: RunInfo object.
+
+        Returns:
+            Dictionary suitable for project detail template rendering,
+            or None if the run is corrupted.
+        """
+        if run.is_corrupted:
+            return None
+
+        return {
+            "name": run.name,
+            "last_update": int(run.last_update.timestamp() * 1000) if run.last_update else 0,
+            "formatted_last_update": (run.last_update.strftime("%B %d, %Y at %I:%M %p") if run.last_update else "N/A"),
+            "is_finished": run.is_finished,
+            "is_wip": run.status.value == "wip",
+            "status": run.status.value,
+        }
+
+    @staticmethod
+    def format_artifact_for_template(artifact: dict[str, Any]) -> dict[str, Any]:
+        """Format an artifact for template rendering with category flags.
+
+        Args:
+            artifact: Artifact dictionary.
+
+        Returns:
+            Dictionary with category boolean flags added.
+        """
+        category = artifact.get("category")
+        return {
+            **artifact,
+            "is_code": category == "code",
+            "is_config": category == "config",
+            "is_model": category == "model",
+            "is_data": category == "data",
+            "is_other": category == "other" or category is None,
+        }

src/aspara/dashboard/static/css/input.css

@@ -0,0 +1,217 @@
+@import "tailwindcss";
+@source "../../templates/**/*.mustache";
+
+/* === Global reduced-motion guard ===
+ * Disable all CSS animations and transitions when the user has
+ * requested reduced motion at the OS / browser level. This is the
+ * single source of truth for reduced-motion handling — component-
+ * specific @media blocks are no longer needed.
+ * Order matters: this must come after @import "tailwindcss" so it
+ * can override Tailwind's animate-* utilities (e.g. animate-pulse).
+ */
+@media (prefers-reduced-motion: reduce) {
+    *,
+    ::before,
+    ::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+        scroll-behavior: auto !important;
+    }
+}
+
+@theme {
+  --color-action: #2C2520;
+  --color-action-hover: #1a1512;
+  --color-action-disabled: #d4cfc9;
+  
+  --color-secondary: #8B7F75;
+  --color-secondary-hover: #6B5F55;
+  
+  --color-accent: #CC785C;
+  --color-accent-hover: #B5654A;
+  --color-accent-light: #E8A892;
+  
+  --color-base-bg: #F5F3F0;
+  --color-base-border: #E6E3E0;
+  --color-base-surface: #FDFCFB;
+  
+  --color-text-primary: #2C2520;
+  --color-text-secondary: #6B5F55;
+  --color-text-muted: #9B8F85;
+  
+  --color-status-error: #C84C3C;
+  --color-status-success: #5A8B6F;
+  --color-status-warning: #D4864E;
+  
+  --font-family-sans: "Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --font-family-mono: "JetBrains Mono", Consolas, Monaco, monospace;
+  
+  --radius-button: 0.5rem;
+}
+
+/* Custom styles beyond Tailwind */
+.plot-container {
+    height: 24rem;
+    background: #FDFCFB;
+    padding: 1rem;
+    border-radius: 0;
+    border: 1px solid #E6E3E0;
+    box-shadow: none;
+}
+
+.sidebar {
+    width: 16rem;
+    background: #FDFCFB;
+    border: 1px solid #E6E3E0;
+    box-shadow: none;
+}
+
+/* Sidebar animation - optimized for responsiveness */
+#runs-sidebar {
+    transition: width 250ms cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.content-area {
+    padding: 2rem;
+    flex: 1;
+}
+
+/* === @jcubic/tagger Aspara Theme Override === */
+
+/* Container - border and background only */
+.tagger {
+    border: 1px solid var(--color-base-border);
+    border-radius: 0.375rem;
+    background: var(--color-base-surface);
+}
+
+/* Tags - color and border-radius only, keep original padding/display */
+.tagger > ul > li:not(.tagger-new) > :first-child {
+    background: var(--color-base-bg);
+    border: 1px solid var(--color-base-border);
+    border-radius: 9999px;
+    /* padding is kept as original 4px 4px 4px 8px - do not override */
+}
+
+/* Tag text color */
+.tagger > ul > li:not(.tagger-new) span.label {
+    color: var(--color-text-muted);
+}
+
+/* Close button */
+.tagger li a.close {
+    color: var(--color-text-muted);
+}
+.tagger li a.close:hover {
+    color: var(--color-text-primary);
+}
+
+/* Input field */
+.tagger .tagger-new input {
+    font-size: 0.75rem;
+    color: var(--color-text-primary);
+}
+.tagger .tagger-new input::placeholder {
+    color: var(--color-text-muted);
+}
+
+/* === Status Icon Styles (based on data-status attribute) === */
+
+[data-status="wip"] {
+    @apply animate-pulse text-status-warning;
+}
+
+[data-status="completed"] {
+    @apply text-status-success;
+}
+
+[data-status="failed"] {
+    @apply text-status-error;
+}
+
+[data-status="maybe_failed"] {
+    @apply text-status-warning;
+}
+
+/* === Note Editor Cursor Styles === */
+
+/* Placeholder (Add note...) cursor */
+.note-content .text-text-muted.italic {
+    cursor: pointer;
+}
+
+/* Edit link cursor */
+.note-edit-btn {
+    cursor: pointer;
+}
+
+/* === Dialog Styles === */
+
+dialog.delete-dialog {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    margin: 0;
+    border: 1px solid var(--color-base-border);
+    border-radius: 0.5rem;
+    background: var(--color-base-surface);
+    box-shadow: 0 25px 50px -12px rgb(0 0 0 / 0.25);
+    max-width: 28rem;
+    width: calc(100% - 2rem);
+}
+
+dialog.delete-dialog::backdrop {
+    background: rgb(0 0 0 / 0.5);
+}
+
+/* === Card Interactive Styles === */
+
+/* Common card styles */
+.card-interactive {
+    @apply transition-colors duration-150 outline-none;
+    @apply hover:border-accent;
+    @apply focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2;
+}
+
+/* === SSE Status Indicator === */
+
+.sse-status {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem;
+    font-size: 0.75rem;
+    color: var(--color-text-muted);
+}
+
+.sse-dot {
+    width: 0.5rem;
+    height: 0.5rem;
+    border-radius: 9999px;
+    flex-shrink: 0;
+}
+
+.sse-dot--connected {
+    background: var(--color-status-success);
+    animation: sse-pulse 2s ease-in-out infinite;
+}
+
+.sse-dot--reconnecting {
+    background: var(--color-status-warning);
+    animation: sse-blink 1s ease-in-out infinite;
+}
+
+.sse-dot--disconnected {
+    background: var(--color-status-error);
+}
+
+@keyframes sse-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+
+@keyframes sse-blink {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.2; }
+}

src/aspara/dashboard/static/css/tagger.css

@@ -0,0 +1,79 @@
+/**@license
+ *  _____
+ * |_   _|___ ___ ___ ___ ___
+ *   | | | .'| . | . | -_|  _|
+ *   |_| |__,|_  |_  |___|_|
+ *           |___|___|   version 0.6.2
+ *
+ * Tagger - Zero dependency, Vanilla JavaScript Tag Editor
+ *
+ * Copyright (c) 2018-2024 Jakub T. Jankiewicz <https://jcubic.pl/me>
+ * Released under the MIT license
+ */
+/* Border/background defined in input.css */
+.tagger input[type="hidden"] {
+  /* fix for bootstrap */
+  display: none;
+}
+.tagger > ul {
+    display: flex;
+    width: 100%;
+    align-items: center;
+    padding: 4px 5px 0;
+    justify-content: space-between;
+    box-sizing: border-box;
+    height: auto;
+    flex: 0 0 auto;
+    overflow-y: auto;
+    margin: 0;
+    list-style: none;
+}
+.tagger > ul > li {
+    padding-bottom: 0.4rem;
+    margin: 0.4rem 5px 4px;
+}
+.tagger > ul > li:not(.tagger-new) a,
+.tagger > ul > li:not(.tagger-new) a:visited {
+    text-decoration: none;
+    /* color defined in input.css */
+}
+.tagger > ul > li:not(.tagger-new) > :first-child {
+    padding: 4px 4px 4px 8px;
+    /* background, border, border-radius defined in input.css */
+}
+.tagger > ul > li:not(.tagger-new) > span,
+.tagger > ul > li:not(.tagger-new) > a > span {
+    white-space: nowrap;
+}
+.tagger li a.close {
+    padding: 4px;
+    margin-left: 4px;
+    /* for bootstrap */
+    float: none;
+    filter: alpha(opacity=100);
+    opacity: 1;
+    font-size: 16px;
+    line-height: 16px;
+}
+.tagger li a.close:hover {
+    /* color defined in input.css */
+}
+.tagger .tagger-new input {
+    border: none;
+    outline: none;
+    box-shadow: none;
+    width: 100%;
+    padding-left: 0;
+    box-sizing: border-box;
+    background: transparent;
+}
+.tagger .tagger-new {
+    flex-grow: 1;
+    position: relative;
+    min-width: 40px;
+    width: 1px;
+}
+.tagger.wrap > ul {
+    flex-wrap: wrap;
+    justify-content: start;
+}

src/aspara/dashboard/static/js/api/delete-api.js

@@ -0,0 +1,89 @@
+/**
+ * Delete API utility functions
+ * Pure API calls without UI logic
+ */
+
+import { isDev } from '../dev-mode.js';
+
+/**
+ * Parse an error response, returning a meaningful message.
+ * In dev mode, includes the raw response body for debugging.
+ * @param {Response} response - The failed fetch response
+ * @returns {Promise<string>} Error message
+ */
+async function parseErrorResponse(response) {
+  let detail = 'Unknown error';
+  let rawBody = null;
+  try {
+    const errorData = await response.json();
+    detail = errorData.detail || detail;
+  } catch {
+    detail = `Server error: ${response.status}`;
+    if (isDev()) {
+      try {
+        rawBody = await response.text();
+      } catch {
+        // ignore
+      }
+    }
+  }
+  if (isDev() && rawBody) {
+    return `${detail} (raw: ${rawBody.slice(0, 200)})`;
+  }
+  return detail;
+}
+
+/**
+ * Delete a project via API
+ * @param {string} projectName - The project name to delete
+ * @returns {Promise<object>} - Response data
+ * @throws {Error} - API error
+ */
+export async function deleteProjectApi(projectName) {
+  const response = await fetch(`/api/projects/${encodeURIComponent(projectName)}`, {
+    method: 'DELETE',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Requested-With': 'XMLHttpRequest',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(await parseErrorResponse(response));
+  }
+
+  // Handle 204 No Content responses
+  if (response.status === 204) {
+    return { message: 'Project deleted successfully' };
+  }
+
+  return response.json();
+}
+
+/**
+ * Delete a run via API
+ * @param {string} projectName - The project name
+ * @param {string} runName - The run name to delete
+ * @returns {Promise<object>} - Response data
+ * @throws {Error} - API error
+ */
+export async function deleteRunApi(projectName, runName) {
+  const response = await fetch(`/api/projects/${encodeURIComponent(projectName)}/runs/${encodeURIComponent(runName)}`, {
+    method: 'DELETE',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Requested-With': 'XMLHttpRequest',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(await parseErrorResponse(response));
+  }
+
+  // Handle 204 No Content responses
+  if (response.status === 204) {
+    return { message: 'Run deleted successfully' };
+  }
+
+  return response.json();
+}

src/aspara/dashboard/static/js/chart.js

@@ -0,0 +1,454 @@
+/**
+ * Canvas-based chart component for metrics visualization.
+ * Supports multiple series, zoom, hover tooltips, and data export.
+ */
+import { ChartColorPalette } from './chart/color-palette.js';
+import { ChartControls } from './chart/controls.js';
+import { ChartExport } from './chart/export.js';
+import { ChartInteraction } from './chart/interaction.js';
+import { ChartRenderer } from './chart/renderer.js';
+import { calculateDataRanges } from './chart/interaction-utils.js';
+import { YScale, computePaddedYRange, isLogScale, isValidLogValue, valueToChartY } from './chart/scale.js';
+
+export class Chart {
+  // Chart layout constants
+  static MARGIN = 60;
+  static CANVAS_SCALE_FACTOR = 1.5; // Reduced from 2.5 for better performance
+  static SIZE_UPDATE_RETRY_DELAY_MS = 100;
+  static FULLSCREEN_UPDATE_DELAY_MS = 100;
+  static MIN_DRAG_DISTANCE = 10;
+
+  // Grid constants
+  static X_GRID_COUNT = 10;
+  static Y_GRID_COUNT = 8;
+  static Y_PADDING_RATIO = 0.1;
+
+  // Style constants
+  static LINE_WIDTH = 1.5; // Normal view
+  static LINE_WIDTH_FULLSCREEN = 2.5; // Fullscreen view
+  static GRID_LINE_WIDTH = 0.5;
+  static LEGEND_ITEM_SPACING = 16;
+  static LEGEND_LINE_LENGTH = 16;
+  static LEGEND_TEXT_OFFSET = 4;
+  static LEGEND_Y_OFFSET = 30;
+
+  // Animation constants
+  static ANIMATION_PULSE_DURATION_MS = 1000;
+
+  constructor(containerId, options = {}) {
+    this.container = document.querySelector(containerId);
+    if (!this.container) {
+      throw new Error(`Container ${containerId} not found`);
+    }
+
+    this.data = null;
+    this.width = 0;
+    this.height = 0;
+    this.onZoomChange = options.onZoomChange || null;
+    this.onYScaleChange = options.onYScaleChange || null;
+    this.yScale = options.yScale || YScale.LINEAR;
+
+    // Color palette for managing series styles
+    this.colorPalette = new ChartColorPalette();
+
+    // Initialize modules
+    this.renderer = new ChartRenderer(this);
+    this.chartExport = new ChartExport(this);
+    this.interaction = new ChartInteraction(this, this.renderer);
+    this.controls = new ChartControls(this, this.chartExport);
+
+    this.hoverPoint = null;
+
+    this.zoomState = {
+      active: false,
+      startX: null,
+      startY: null,
+      currentX: null,
+      currentY: null,
+    };
+    this.zoom = { x: null, y: null };
+
+    // Fullscreen event handler (stored for cleanup)
+    this.fullscreenChangeHandler = null;
+
+    // Data range cache for performance optimization
+    this._cachedDataRanges = null;
+    this._lastDataRef = null;
+    this._lastScale = null;
+
+    this.init();
+  }
+
+  init() {
+    this.container.innerHTML = '';
+
+    this.canvas = document.createElement('canvas');
+    this.canvas.style.border = '1px solid #e5e7eb';
+    this.canvas.style.display = 'block';
+    this.canvas.style.maxWidth = '100%';
+
+    // Accessibility: expose the canvas as a decorative image whose
+    // accessible name is derived from the chart's <h3> title via
+    // aria-labelledby. The title id is stashed on the container div by
+    // createMetricChartContainer(); when absent (e.g. standalone Chart
+    // usage) fall back to a generic label.
+    this.canvas.setAttribute('role', 'img');
+    const titleId = this.container.dataset.ariaLabelledby;
+    if (titleId) {
+      this.canvas.setAttribute('aria-labelledby', titleId);
+    } else {
+      this.canvas.setAttribute('aria-label', 'Metrics line chart');
+    }
+
+    this.container.appendChild(this.canvas);
+    this.ctx = this.canvas.getContext('2d');
+
+    this.ctx.imageSmoothingEnabled = true;
+    this.ctx.imageSmoothingQuality = 'high';
+
+    // For throttling draw calls
+    this.pendingDraw = false;
+
+    this.updateSize();
+    this.interaction.setupEventListeners();
+    this.setupFullscreenListener();
+    this.controls.create();
+  }
+
+  updateSize() {
+    // Use clientWidth/clientHeight to get size excluding border
+    const rect = this.container.getBoundingClientRect?.();
+    const width = this.container.clientWidth || rect?.width || 0;
+    const height = this.container.clientHeight || rect?.height || 0;
+
+    // Retry later if container is not yet visible
+    if (width === 0 || height === 0) {
+      // Avoid infinite retry loops - only retry if we haven't set a size yet
+      if (this.width === 0 && this.height === 0) {
+        setTimeout(() => this.updateSize(), Chart.SIZE_UPDATE_RETRY_DELAY_MS);
+      }
+      return;
+    }
+
+    this.width = width;
+    this.height = height;
+
+    this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+
+    const dpr = window.devicePixelRatio || 1;
+    const totalScale = dpr * Chart.CANVAS_SCALE_FACTOR;
+
+    // Set internal canvas resolution (high-DPI)
+    this.canvas.width = this.width * totalScale;
+    this.canvas.height = this.height * totalScale;
+
+    // Set CSS display size to exact pixel values (matching internal aspect ratio)
+    this.canvas.style.width = `${this.width}px`;
+    this.canvas.style.height = `${this.height}px`;
+    this.canvas.style.display = 'block';
+
+    this.ctx.scale(totalScale, totalScale);
+
+    // Redraw if data is already set
+    if (this.data) {
+      this.draw();
+    }
+  }
+
+  setData(data) {
+    this.data = data;
+    // Invalidate data range cache when data changes
+    this._cachedDataRanges = null;
+    this._lastDataRef = null;
+    if (data?.series) {
+      this.colorPalette.ensureRunStyles(data.series.map((s) => s.name));
+    }
+    this.draw();
+  }
+
+  /**
+   * Get cached data ranges, recalculating only when data or scale changes.
+   * @returns {Object|null} Object with xMin, xMax, yMin, yMax or null
+   */
+  _getDataRanges() {
+    if (this.data?.series !== this._lastDataRef || this.yScale !== this._lastScale) {
+      this._lastDataRef = this.data?.series;
+      this._lastScale = this.yScale;
+      this._cachedDataRanges = this._calculateDataRanges();
+    }
+    return this._cachedDataRanges;
+  }
+
+  /**
+   * Calculate data ranges from all series.
+   * For log scale, only positive values are considered.
+   * @returns {Object|null} Object with xMin, xMax, yMin, yMax or null
+   */
+  _calculateDataRanges() {
+    return calculateDataRanges(this.data?.series || [], this.yScale);
+  }
+
+  draw() {
+    // Skip drawing if canvas size is not yet initialized
+    if (this.width === 0 || this.height === 0) {
+      return;
+    }
+
+    this.ctx.fillStyle = 'white';
+    this.ctx.fillRect(0, 0, this.width, this.height);
+
+    if (!this.data) {
+      console.warn('Chart.draw(): No data set');
+      return;
+    }
+
+    if (!this.data.series || !Array.isArray(this.data.series)) {
+      console.error('Chart.draw(): Invalid data format - series must be an array');
+      return;
+    }
+
+    if (this.data.series.length === 0) {
+      console.warn('Chart.draw(): Empty series array');
+      return;
+    }
+
+    const margin = Chart.MARGIN;
+    const plotWidth = this.width - margin * 2;
+    const plotHeight = this.height - margin * 2;
+
+    // Use cached data ranges for performance
+    const ranges = this._getDataRanges();
+    if (!ranges) {
+      console.warn('Chart.draw(): No valid data points in series');
+      return;
+    }
+
+    let { xMin, xMax, yMin, yMax } = ranges;
+
+    if (this.zoom.x) {
+      xMin = this.zoom.x.min;
+      xMax = this.zoom.x.max;
+    }
+    if (this.zoom.y) {
+      yMin = this.zoom.y.min;
+      yMax = this.zoom.y.max;
+    }
+
+    if (isLogScale(this.yScale) && (yMin <= 0 || yMax <= 0)) {
+      this.renderer.drawMessage('Log scale requires positive y values');
+      return;
+    }
+
+    const { yMinPadded, yMaxPadded } = computePaddedYRange(yMin, yMax, this.yScale, Chart.Y_PADDING_RATIO);
+
+    this.renderer.drawGrid(margin, plotWidth, plotHeight, xMin, xMax, yMinPadded, yMaxPadded, this.yScale);
+    this.renderer.drawAxisLabels(margin, plotWidth, plotHeight, xMin, xMax, yMinPadded, yMaxPadded, this.yScale);
+
+    // Clip to plot area
+    this.ctx.save();
+    this.ctx.beginPath();
+    this.ctx.rect(margin, margin, plotWidth, plotHeight);
+    this.ctx.clip();
+
+    for (const series of this.data.series) {
+      if (!series.data?.steps?.length) continue;
+      const { steps, values } = series.data;
+
+      const style = this.colorPalette.getRunStyle(series.name);
+
+      this.ctx.strokeStyle = style.borderColor;
+      this.ctx.lineWidth = this.getLineWidth();
+      this.ctx.lineCap = 'round';
+      this.ctx.lineJoin = 'round';
+
+      // Apply border dash pattern
+      if (style.borderDash && style.borderDash.length > 0) {
+        this.ctx.setLineDash(style.borderDash);
+      } else {
+        this.ctx.setLineDash([]);
+      }
+
+      this.ctx.beginPath();
+      let hasValidPoint = false;
+
+      for (let i = 0; i < steps.length; i++) {
+        const value = values[i];
+        if (isLogScale(this.yScale) && !isValidLogValue(value)) {
+          // Break the line at non-positive values; resume at the next valid point.
+          if (hasValidPoint) {
+            this.ctx.stroke();
+            this.ctx.beginPath();
+            hasValidPoint = false;
+          }
+          continue;
+        }
+
+        const x = margin + ((steps[i] - xMin) / (xMax - xMin)) * plotWidth;
+        const y = valueToChartY(value, this.yScale, plotHeight, margin, yMinPadded, yMaxPadded);
+
+        if (!hasValidPoint) {
+          this.ctx.moveTo(x, y);
+          hasValidPoint = true;
+        } else {
+          this.ctx.lineTo(x, y);
+        }
+      }
+
+      this.ctx.stroke();
+      this.ctx.setLineDash([]); // Reset dash pattern
+    }
+
+    this.ctx.restore();
+    this.renderer.drawLegend();
+    this.interaction.drawHoverEffects();
+    this.interaction.drawZoomSelection();
+  }
+
+  getLineWidth() {
+    if (document.fullscreenElement === this.container) {
+      return Chart.LINE_WIDTH_FULLSCREEN;
+    }
+    return Chart.LINE_WIDTH;
+  }
+
+  getRunStyle(seriesName) {
+    return this.colorPalette.getRunStyle(seriesName);
+  }
+
+  setupFullscreenListener() {
+    // Store handler for cleanup
+    this.fullscreenChangeHandler = () => {
+      setTimeout(() => {
+        this.updateSize();
+      }, Chart.FULLSCREEN_UPDATE_DELAY_MS);
+    };
+    document.addEventListener('fullscreenchange', this.fullscreenChangeHandler);
+  }
+
+  resetZoom() {
+    this.zoom.x = null;
+    this.zoom.y = null;
+    this.draw();
+  }
+
+  /**
+   * Toggle the y-axis scale between linear and logarithmic.
+   * Zoom is cleared because a linear zoom range does not translate to log space.
+   */
+  toggleYScale() {
+    this.setYScale(this.yScale === YScale.LOG ? YScale.LINEAR : YScale.LOG);
+  }
+
+  /**
+   * Set the y-axis scale explicitly.
+   * @param {string} scale - YScale.LINEAR or YScale.LOG
+   */
+  setYScale(scale) {
+    if (scale !== YScale.LINEAR && scale !== YScale.LOG) return;
+    this.yScale = scale;
+    this.zoom.y = null;
+    this.hoverPoint = null;
+    if (this.onYScaleChange) {
+      this.onYScaleChange(this.yScale);
+    }
+    this.draw();
+  }
+
+  setExternalZoom(zoomState) {
+    if (zoomState?.x) {
+      this.zoom.x = { ...zoomState.x };
+      this.draw();
+    }
+  }
+
+  /**
+   * Add a new data point to an existing series (SoA format)
+   * @param {string} runName - Name of the run
+   * @param {number} step - Step number
+   * @param {number} value - Metric value
+   */
+  addDataPoint(runName, step, value) {
+    console.log(`[Chart] addDataPoint called: run=${runName}, step=${step}, value=${value}`);
+
+    if (!this.data || !this.data.series) {
+      console.warn('[Chart] No data or series available');
+      return;
+    }
+
+    // Find the series for this run
+    let series = this.data.series.find((s) => s.name === runName);
+
+    if (!series) {
+      // Create new series if it doesn't exist (SoA format)
+      series = {
+        name: runName,
+        data: { steps: [], values: [] },
+      };
+      this.data.series.push(series);
+    }
+
+    const { steps, values } = series.data;
+
+    // Binary search to find insertion position
+    let left = 0;
+    let right = steps.length;
+    while (left < right) {
+      const mid = (left + right) >> 1;
+      if (steps[mid] < step) {
+        left = mid + 1;
+      } else if (steps[mid] > step) {
+        right = mid;
+      } else {
+        // Exact match - update existing value
+        values[mid] = value;
+        this.scheduleDraw();
+        return;
+      }
+    }
+
+    // Insert at the found position (usually at the end, so O(1) in practice)
+    steps.splice(left, 0, step);
+    values.splice(left, 0, value);
+
+    // Invalidate data range cache when data changes
+    this._cachedDataRanges = null;
+
+    // Schedule redraw using requestAnimationFrame to throttle updates
+    this.scheduleDraw();
+  }
+
+  /**
+   * Schedule a draw operation using requestAnimationFrame
+   * This prevents excessive redraws when multiple data points arrive rapidly
+   */
+  scheduleDraw() {
+    console.log('[Chart] scheduleDraw called, pendingDraw:', this.pendingDraw);
+
+    if (this.pendingDraw) {
+      return; // Draw already scheduled
+    }
+
+    this.pendingDraw = true;
+    requestAnimationFrame(() => {
+      console.log('[Chart] requestAnimationFrame callback executing');
+      this.pendingDraw = false;
+      this.draw();
+    });
+  }
+
+  /**
+   * Clean up event listeners and resources.
+   */
+  destroy() {
+    if (this.fullscreenChangeHandler) {
+      document.removeEventListener('fullscreenchange', this.fullscreenChangeHandler);
+      this.fullscreenChangeHandler = null;
+    }
+    if (this.interaction) {
+      this.interaction.destroy();
+    }
+    if (this.controls) {
+      this.controls.destroy();
+    }
+  }
+}

src/aspara/dashboard/static/js/chart/color-palette.js

@@ -0,0 +1,198 @@
+/**
+ * ChartColorPalette - Color management for chart series
+ * Handles color generation, style assignment, and run-to-style mapping
+ */
+export class ChartColorPalette {
+  constructor() {
+    // Modern 16-color base palette with well-distributed hues for easy differentiation
+    // Colors are arranged by hue (0-360°) with ~22.5° spacing for maximum visual distinction
+    // Red-family colors and dark blues have varied saturation for better distinction
+    this.baseColors = [
+      '#FF3B47', // red (0°) - high saturation
+      '#F77F00', // orange (30°)
+      '#FCBF49', // yellow (45°)
+      '#06D6A0', // mint/turquoise (165°)
+      '#118AB2', // blue (195°)
+      '#69808b', // dark blue (200°) - higher saturation, more vivid
+      '#4361EE', // bright blue (225°)
+      '#7209B7', // purple (270°)
+      '#E85D9A', // magenta (330°) - medium saturation, lighter
+      '#B8252D', // crimson (355°) - lower saturation, darker
+      '#F4A261', // peach (35°)
+      '#2A9D8F', // teal (170°)
+      '#408828', // dark teal (190°) - lower saturation, more muted
+      '#3A86FF', // sky blue (215°)
+      '#8338EC', // violet (265°)
+      '#FF1F7D', // hot pink (340°) - very high saturation
+    ];
+
+    // Border dash patterns for additional differentiation
+    this.borderDashPatterns = [
+      [], // solid
+      [6, 4], // dashed
+      [2, 3], // dotted
+      [10, 3, 2, 3], // dash-dot
+    ];
+
+    // Registry to maintain stable run->style mapping
+    this.runStyleRegistry = new Map();
+    this.nextStyleIndex = 0;
+  }
+
+  /**
+   * Convert hex color to RGB
+   * @param {string} hex - Hex color string
+   * @returns {Object|null} RGB object or null if invalid
+   */
+  hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+      ? {
+          r: Number.parseInt(result[1], 16),
+          g: Number.parseInt(result[2], 16),
+          b: Number.parseInt(result[3], 16),
+        }
+      : null;
+  }
+
+  /**
+   * Convert RGB to HSL
+   * @param {number} r - Red (0-255)
+   * @param {number} g - Green (0-255)
+   * @param {number} b - Blue (0-255)
+   * @returns {Object} HSL object
+   */
+  rgbToHsl(r, g, b) {
+    const rNorm = r / 255;
+    const gNorm = g / 255;
+    const bNorm = b / 255;
+
+    const max = Math.max(rNorm, gNorm, bNorm);
+    const min = Math.min(rNorm, gNorm, bNorm);
+    let h;
+    let s;
+    const l = (max + min) / 2;
+
+    if (max === min) {
+      h = 0;
+      s = 0;
+    } else {
+      const d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+      switch (max) {
+        case rNorm:
+          h = ((gNorm - bNorm) / d + (gNorm < bNorm ? 6 : 0)) / 6;
+          break;
+        case gNorm:
+          h = ((bNorm - rNorm) / d + 2) / 6;
+          break;
+        case bNorm:
+          h = ((rNorm - gNorm) / d + 4) / 6;
+          break;
+      }
+    }
+
+    return { h: h * 360, s: s * 100, l: l * 100 };
+  }
+
+  /**
+   * Apply variant transformation to HSL color
+   * @param {Object} hsl - HSL color object
+   * @param {number} variantIndex - Variant index (0-2)
+   * @returns {Object} Modified HSL object
+   */
+  applyVariant(hsl, variantIndex) {
+    const variants = [
+      { sDelta: 0, lDelta: 0 }, // normal
+      { sDelta: -15, lDelta: -6 }, // muted
+      { sDelta: 8, lDelta: 6 }, // bright
+    ];
+
+    const variant = variants[variantIndex];
+    let s = hsl.s + variant.sDelta;
+    let l = hsl.l + variant.lDelta;
+
+    // Clamp to safe ranges
+    s = Math.max(35, Math.min(95, s));
+    l = Math.max(30, Math.min(70, l));
+
+    return { h: hsl.h, s, l };
+  }
+
+  /**
+   * Convert HSL to CSS string
+   * @param {Object} hsl - HSL color object
+   * @returns {string} CSS HSL string
+   */
+  hslToString(hsl) {
+    return `hsl(${Math.round(hsl.h)}, ${Math.round(hsl.s)}%, ${Math.round(hsl.l)}%)`;
+  }
+
+  /**
+   * Generate style for a given style index
+   * @param {number} styleIndex - Style index
+   * @returns {Object} Style object with borderColor, backgroundColor, borderDash
+   */
+  generateStyle(styleIndex) {
+    const M = this.baseColors.length; // 16
+    const V = 3; // variants
+    const D = this.borderDashPatterns.length; // 4
+
+    const baseIndex = styleIndex % M;
+    const variantIndex = Math.floor(styleIndex / M) % V;
+    const dashIndex = Math.floor(styleIndex / (M * V)) % D;
+
+    // Get base color and convert to HSL
+    const hex = this.baseColors[baseIndex];
+    const rgb = this.hexToRgb(hex);
+    const hsl = this.rgbToHsl(rgb.r, rgb.g, rgb.b);
+
+    // Apply variant
+    const variantHsl = this.applyVariant(hsl, variantIndex);
+    const borderColor = this.hslToString(variantHsl);
+
+    // Get border dash pattern
+    const borderDash = this.borderDashPatterns[dashIndex];
+
+    return {
+      borderColor,
+      backgroundColor: borderColor,
+      borderDash,
+    };
+  }
+
+  /**
+   * Ensure all runs have stable styles assigned
+   * @param {Array<string>} runIds - Array of run IDs
+   */
+  ensureRunStyles(runIds) {
+    // Sort run IDs for stable ordering
+    const sortedRunIds = [...new Set(runIds)].sort();
+
+    for (const runId of sortedRunIds) {
+      if (!this.runStyleRegistry.has(runId)) {
+        const style = this.generateStyle(this.nextStyleIndex);
+        this.runStyleRegistry.set(runId, style);
+        this.nextStyleIndex++;
+      }
+    }
+  }
+
+  /**
+   * Get style for a specific run
+   * @param {string} runId - Run ID
+   * @returns {Object} Style object
+   */
+  getRunStyle(runId) {
+    return this.runStyleRegistry.get(runId) || this.generateStyle(0);
+  }
+
+  /**
+   * Reset the style registry
+   */
+  reset() {
+    this.runStyleRegistry.clear();
+    this.nextStyleIndex = 0;
+  }
+}

src/aspara/dashboard/static/js/chart/controls.js

@@ -0,0 +1,467 @@
+import { CHART_CONTROL_LABELS, ICON_DOWNLOAD, ICON_FULLSCREEN, ICON_HELP, ICON_RESET_ZOOM } from '../html-utils.js';
+
+/**
+ * Apply shared styling and ARIA attributes to a chart control button.
+ * @param {HTMLButtonElement} button
+ * @param {string} label - Accessible name (also used as tooltip)
+ */
+function styleControlButton(button, label) {
+  button.type = 'button';
+  button.setAttribute('aria-label', label);
+  button.title = label;
+  button.style.cssText = `
+        width: 32px;
+        height: 32px;
+        border: 1px solid #ddd;
+        background: white;
+        cursor: pointer;
+        border-radius: 6px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: #555;
+    `;
+}
+
+export class ChartControls {
+  constructor(chart, chartExport) {
+    this.chart = chart;
+    this.chartExport = chartExport;
+    this.buttonContainer = null;
+    this.resetButton = null;
+    this.fullSizeButton = null;
+    this.downloadButton = null;
+    this.downloadMenu = null;
+    this.helpButton = null;
+    this.helpPopover = null;
+    this.logScaleControl = null;
+    this.logScaleCheckbox = null;
+
+    // Document click handler (stored for cleanup)
+    this.documentClickHandler = null;
+    // fullscreenchange handler (stored for cleanup)
+    this.fullscreenChangeHandler = null;
+    // Keydown handler for Esc / arrow keys inside open menus (stored for cleanup)
+    this._menuKeydownHandler = null;
+  }
+
+  create() {
+    this.chart.container.style.position = 'relative';
+
+    this.buttonContainer = document.createElement('div');
+    this.buttonContainer.style.cssText = `
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            display: flex;
+            gap: 8px;
+            z-index: 10;
+        `;
+
+    this.createLogScaleControl();
+    this.createResetButton();
+    this.createFullSizeButton();
+    this.createDownloadButton();
+    this.createHelpButton();
+
+    this.buttonContainer.appendChild(this.logScaleControl);
+    this.buttonContainer.appendChild(this.resetButton);
+    this.buttonContainer.appendChild(this.fullSizeButton);
+    this.buttonContainer.appendChild(this.downloadButton);
+    this.buttonContainer.appendChild(this.helpButton);
+    this.chart.container.appendChild(this.buttonContainer);
+
+    this.updateLogScaleControl();
+    // Wire up callback so the checkbox reflects scale changes from other sources
+    // (e.g. keyboard shortcuts) without coupling Chart to ChartControls.
+    const existingYScaleCallback = this.chart.onYScaleChange;
+    this.chart.onYScaleChange = (scale) => {
+      if (existingYScaleCallback) existingYScaleCallback(scale);
+      this.updateLogScaleControl();
+    };
+  }
+
+  createResetButton() {
+    this.resetButton = document.createElement('button');
+    this.resetButton.innerHTML = ICON_RESET_ZOOM;
+    styleControlButton(this.resetButton, CHART_CONTROL_LABELS.resetZoom);
+
+    this.attachButtonHover(this.resetButton);
+    this.resetButton.addEventListener('click', () => this.chart.resetZoom());
+  }
+
+  createFullSizeButton() {
+    this.fullSizeButton = document.createElement('button');
+    this.fullSizeButton.innerHTML = ICON_FULLSCREEN;
+    styleControlButton(this.fullSizeButton, CHART_CONTROL_LABELS.enterFullscreen);
+
+    this.attachButtonHover(this.fullSizeButton);
+    this.fullSizeButton.addEventListener('click', () => this.fitToFullSize());
+
+    // Keep the title/aria-label in sync with the actual fullscreen state so
+    // the tooltip reflects what clicking the button will do (e.g. after the
+    // user exits fullscreen via Esc).
+    this.fullscreenChangeHandler = () => {
+      if (!this.fullSizeButton) return;
+      const label = document.fullscreenElement
+        ? CHART_CONTROL_LABELS.exitFullscreen
+        : CHART_CONTROL_LABELS.enterFullscreen;
+      this.fullSizeButton.title = label;
+      this.fullSizeButton.setAttribute('aria-label', label);
+    };
+    document.addEventListener('fullscreenchange', this.fullscreenChangeHandler);
+  }
+
+  createDownloadButton() {
+    this.downloadButton = document.createElement('button');
+    this.downloadButton.innerHTML = ICON_DOWNLOAD;
+    styleControlButton(this.downloadButton, CHART_CONTROL_LABELS.download);
+    this.downloadButton.style.position = 'relative';
+    // Declare the popup menu relationship for AT users.
+    this.downloadButton.setAttribute('aria-haspopup', 'menu');
+    this.downloadButton.setAttribute('aria-expanded', 'false');
+
+    this.downloadMenu = document.createElement('div');
+    this.downloadMenu.setAttribute('role', 'menu');
+    this.downloadMenu.style.cssText = `
+            position: absolute;
+            top: 100%;
+            right: 0;
+            background: white;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+            display: none;
+            flex-direction: column;
+            width: 120px;
+            z-index: 20;
+        `;
+
+    const downloadOptions = [
+      { format: 'CSV', label: 'CSV format' },
+      { format: 'SVG', label: 'SVG image' },
+      { format: 'PNG', label: 'PNG image' },
+    ];
+
+    for (const option of downloadOptions) {
+      const menuItem = document.createElement('button');
+      menuItem.textContent = option.label;
+      menuItem.setAttribute('role', 'menuitem');
+      menuItem.style.cssText = `
+                padding: 8px 12px;
+                text-align: left;
+                background: none;
+                border: none;
+                cursor: pointer;
+                font-size: 13px;
+                color: #333;
+            `;
+      menuItem.addEventListener('mouseenter', () => {
+        menuItem.style.background = '#f5f5f5';
+      });
+      menuItem.addEventListener('mouseleave', () => {
+        menuItem.style.background = 'none';
+      });
+      menuItem.addEventListener('click', (e) => {
+        e.stopPropagation();
+        this.chartExport.downloadData(option.format);
+        this.toggleDownloadMenu(false);
+      });
+      this.downloadMenu.appendChild(menuItem);
+    }
+
+    this.downloadButton.appendChild(this.downloadMenu);
+
+    this.attachButtonHover(this.downloadButton);
+    this.downloadButton.addEventListener('click', () => this.toggleDownloadMenu());
+  }
+
+  createLogScaleControl() {
+    const controlId = `logscale-${Math.random().toString(36).slice(2, 9)}`;
+
+    this.logScaleControl = document.createElement('label');
+    this.logScaleControl.htmlFor = controlId;
+    this.logScaleControl.style.cssText = `
+            height: 32px;
+            border: 1px solid #ddd;
+            background: white;
+            border-radius: 6px;
+            display: flex;
+            align-items: center;
+            padding: 0 10px;
+            gap: 6px;
+            font-size: 12px;
+            color: #555;
+            cursor: pointer;
+            user-select: none;
+        `;
+
+    this.logScaleCheckbox = document.createElement('input');
+    this.logScaleCheckbox.type = 'checkbox';
+    this.logScaleCheckbox.id = controlId;
+    this.logScaleCheckbox.setAttribute('aria-label', CHART_CONTROL_LABELS.toggleLogScale);
+    this.logScaleCheckbox.style.cursor = 'pointer';
+
+    const labelText = document.createElement('span');
+    labelText.textContent = 'logscale';
+
+    this.logScaleControl.appendChild(this.logScaleCheckbox);
+    this.logScaleControl.appendChild(labelText);
+
+    this.logScaleControl.addEventListener('mouseenter', () => {
+      this.logScaleControl.style.background = '#f5f5f5';
+      this.logScaleControl.style.borderColor = '#bbb';
+    });
+    this.logScaleControl.addEventListener('mouseleave', () => {
+      this.logScaleControl.style.background = 'white';
+      this.logScaleControl.style.borderColor = '#ddd';
+    });
+
+    this.logScaleCheckbox.addEventListener('change', () => {
+      this.chart.toggleYScale();
+    });
+  }
+
+  updateLogScaleControl() {
+    if (!this.logScaleCheckbox) return;
+    const isLog = this.chart.yScale === 'log';
+    this.logScaleCheckbox.checked = isLog;
+  }
+
+  createHelpButton() {
+    this.helpButton = document.createElement('button');
+    this.helpButton.innerHTML = ICON_HELP;
+    styleControlButton(this.helpButton, CHART_CONTROL_LABELS.help);
+    this.helpButton.style.position = 'relative';
+    // The help popover is informational, not a menu, but it is a popup.
+    this.helpButton.setAttribute('aria-haspopup', 'dialog');
+    this.helpButton.setAttribute('aria-expanded', 'false');
+
+    this.helpPopover = document.createElement('div');
+    this.helpPopover.setAttribute('role', 'dialog');
+    this.helpPopover.style.cssText = `
+            position: absolute;
+            top: 100%;
+            right: 0;
+            background: white;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+            display: none;
+            flex-direction: column;
+            width: 220px;
+            z-index: 20;
+            padding: 10px 12px;
+        `;
+
+    // SSOT: chart interaction descriptions live here. Each button's
+    // `title` attribute stays short; this popover is the canonical place
+    // for the full explanation.
+    const items = [
+      { icon: '✋', text: 'Drag on chart to zoom' },
+      { icon: '↺', text: 'Click reset to restore view' },
+      { icon: '⛶', text: 'Click fullscreen to expand' },
+      { icon: '⤓', text: 'Click download to export data' },
+      { icon: 'log', text: 'Check logscale to toggle y-axis scale' },
+    ];
+
+    for (const item of items) {
+      const row = document.createElement('div');
+      row.style.cssText = `
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                padding: 4px 0;
+                font-size: 13px;
+                color: #333;
+            `;
+      const iconSpan = document.createElement('span');
+      iconSpan.textContent = item.icon;
+      iconSpan.setAttribute('aria-hidden', 'true');
+      iconSpan.style.cssText = 'width: 18px; text-align: center; flex-shrink: 0;';
+      const textSpan = document.createElement('span');
+      textSpan.textContent = item.text;
+      row.appendChild(iconSpan);
+      row.appendChild(textSpan);
+      this.helpPopover.appendChild(row);
+    }
+
+    this.helpButton.appendChild(this.helpPopover);
+
+    this.attachButtonHover(this.helpButton);
+    this.helpButton.addEventListener('click', (e) => {
+      e.stopPropagation();
+      this.toggleHelpPopover();
+    });
+
+    // Reuse the document click handler pattern from the download menu to
+    // close the help popover when clicking outside.
+    const existingHandler = this.documentClickHandler;
+    this.documentClickHandler = (e) => {
+      if (this.downloadButton && !this.downloadButton.contains(e.target)) {
+        this.toggleDownloadMenu(false);
+      }
+      if (this.helpButton && !this.helpButton.contains(e.target)) {
+        this.toggleHelpPopover(false);
+      }
+    };
+    // Replace the previously registered handler (if any) with the unified one.
+    if (existingHandler) {
+      document.removeEventListener('click', existingHandler);
+    }
+    document.addEventListener('click', this.documentClickHandler);
+
+    // Global keydown handler: Esc closes the open popup and returns focus
+    // to the triggering button; arrow keys move between menu items of the
+    // download menu (ARIA Authoring Practices menu pattern).
+    this._menuKeydownHandler = (e) => this._handleMenuKeydown(e);
+    document.addEventListener('keydown', this._menuKeydownHandler);
+  }
+
+  /**
+   * Handle keyboard navigation for open popups (Esc / Arrow / Home / End).
+   * Follows the ARIA Authoring Practices Guide menu pattern.
+   */
+  _handleMenuKeydown(e) {
+    const downloadOpen = this.downloadMenu?.style.display === 'flex';
+    const helpOpen = this.helpPopover?.style.display === 'flex';
+    if (!downloadOpen && !helpOpen) return;
+
+    // Esc closes whichever popup is open and returns focus to its trigger.
+    if (e.key === 'Escape') {
+      e.preventDefault();
+      if (downloadOpen) {
+        this.toggleDownloadMenu(false);
+        this.downloadButton?.focus();
+      } else if (helpOpen) {
+        this.toggleHelpPopover(false);
+        this.helpButton?.focus();
+      }
+      return;
+    }
+
+    // Arrow / Home / End only apply to the download menu (role=menu).
+    if (!downloadOpen) return;
+
+    const items = Array.from(this.downloadMenu.querySelectorAll('[role="menuitem"]'));
+    if (items.length === 0) return;
+    const currentIndex = items.indexOf(document.activeElement);
+
+    if (e.key === 'ArrowDown') {
+      e.preventDefault();
+      items[(currentIndex + 1) % items.length].focus();
+    } else if (e.key === 'ArrowUp') {
+      e.preventDefault();
+      items[(currentIndex - 1 + items.length) % items.length].focus();
+    } else if (e.key === 'Home') {
+      e.preventDefault();
+      items[0].focus();
+    } else if (e.key === 'End') {
+      e.preventDefault();
+      items[items.length - 1].focus();
+    }
+  }
+
+  toggleHelpPopover(forceState) {
+    if (!this.helpPopover) return;
+    const isVisible = this.helpPopover.style.display === 'flex';
+    const newState = forceState !== undefined ? forceState : !isVisible;
+    this.helpPopover.style.display = newState ? 'flex' : 'none';
+    if (this.helpButton) {
+      this.helpButton.setAttribute('aria-expanded', newState ? 'true' : 'false');
+    }
+    if (newState) {
+      // Move focus into the dialog so AT users perceive the context switch.
+      this.helpPopover.focus?.();
+    }
+  }
+
+  fitToFullSize() {
+    if (!document.fullscreenElement) {
+      if (this.chart.container.requestFullscreen) {
+        this.chart.container.requestFullscreen();
+      } else if (this.chart.container.webkitRequestFullscreen) {
+        this.chart.container.webkitRequestFullscreen();
+      } else if (this.chart.container.mozRequestFullScreen) {
+        this.chart.container.mozRequestFullScreen();
+      } else if (this.chart.container.msRequestFullscreen) {
+        this.chart.container.msRequestFullscreen();
+      }
+      this.fullSizeButton.title = CHART_CONTROL_LABELS.exitFullscreen;
+      this.fullSizeButton.setAttribute('aria-label', CHART_CONTROL_LABELS.exitFullscreen);
+    } else {
+      if (document.exitFullscreen) {
+        document.exitFullscreen();
+      } else if (document.webkitExitFullscreen) {
+        document.webkitExitFullscreen();
+      } else if (document.mozCancelFullScreen) {
+        document.mozCancelFullScreen();
+      } else if (document.msExitFullscreen) {
+        document.msExitFullscreen();
+      }
+      this.fullSizeButton.title = CHART_CONTROL_LABELS.enterFullscreen;
+      this.fullSizeButton.setAttribute('aria-label', CHART_CONTROL_LABELS.enterFullscreen);
+    }
+  }
+
+  toggleDownloadMenu(forceState) {
+    const isVisible = this.downloadMenu.style.display === 'flex';
+    const newState = forceState !== undefined ? forceState : !isVisible;
+
+    this.downloadMenu.style.display = newState ? 'flex' : 'none';
+    if (this.downloadButton) {
+      this.downloadButton.setAttribute('aria-expanded', newState ? 'true' : 'false');
+    }
+    if (newState) {
+      // Move focus to the first menu item so keyboard users can
+      // immediately navigate with arrows (ARIA APG menu pattern).
+      const firstItem = this.downloadMenu.querySelector('[role="menuitem"]');
+      firstItem?.focus();
+    }
+  }
+
+  /**
+   * Attach hover effect to a button element
+   * @param {HTMLButtonElement} button - Button element to attach hover effect
+   */
+  attachButtonHover(button) {
+    button.addEventListener('mouseenter', () => {
+      button.style.background = '#f5f5f5';
+      button.style.borderColor = '#bbb';
+    });
+    button.addEventListener('mouseleave', () => {
+      button.style.background = 'white';
+      button.style.borderColor = '#ddd';
+    });
+  }
+
+  /**
+   * Clean up event listeners and remove DOM elements.
+   */
+  destroy() {
+    if (this.documentClickHandler) {
+      document.removeEventListener('click', this.documentClickHandler);
+      this.documentClickHandler = null;
+    }
+    if (this.fullscreenChangeHandler) {
+      document.removeEventListener('fullscreenchange', this.fullscreenChangeHandler);
+      this.fullscreenChangeHandler = null;
+    }
+    if (this._menuKeydownHandler) {
+      document.removeEventListener('keydown', this._menuKeydownHandler);
+      this._menuKeydownHandler = null;
+    }
+    if (this.buttonContainer?.parentNode) {
+      this.buttonContainer.parentNode.removeChild(this.buttonContainer);
+    }
+    this.buttonContainer = null;
+    this.resetButton = null;
+    this.fullSizeButton = null;
+    this.downloadButton = null;
+    this.downloadMenu = null;
+    this.helpButton = null;
+    this.helpPopover = null;
+    this.logScaleControl = null;
+    this.logScaleCheckbox = null;
+  }
+}

src/aspara/dashboard/static/js/chart/export-utils.js

@@ -0,0 +1,74 @@
+/**
+ * Pure utility functions for chart export
+ * These functions have no side effects and are easy to test
+ */
+
+/**
+ * Generate CSV content from series data (SoA format)
+ * @param {Array} series - Array of series objects with name and data in SoA format
+ * @returns {string} CSV formatted string
+ */
+export function generateCSVContent(series) {
+  const lines = ['series,step,value'];
+
+  for (const s of series) {
+    if (!s.data?.steps?.length) continue;
+    const { steps, values } = s.data;
+
+    const seriesName = s.name.replace(/"/g, '""');
+
+    for (let i = 0; i < steps.length; i++) {
+      lines.push(`"${seriesName}",${steps[i]},${values[i]}`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+/**
+ * Sanitize a string for use as a filename
+ * @param {string} name - Original name
+ * @returns {string} Sanitized filename
+ */
+export function sanitizeFileName(name) {
+  return name.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+}
+
+/**
+ * Get export filename from chart data
+ * @param {Object} data - Chart data object with optional title and series
+ * @returns {string} Filename without extension
+ */
+export function getExportFileName(data) {
+  if (data.title) {
+    return sanitizeFileName(data.title);
+  }
+  if (data.series && data.series.length === 1) {
+    return sanitizeFileName(data.series[0].name);
+  }
+  return 'chart';
+}
+
+/**
+ * Calculate dimensions for zoomed/unzoomed export
+ * @param {Object} chart - Chart object with zoom, width, height, and MARGIN
+ * @returns {Object} Dimensions info including useZoomedArea, margin, plotWidth, plotHeight
+ */
+export function calculateExportDimensions(chart) {
+  const useZoomedArea = chart.zoom.x !== null || chart.zoom.y !== null;
+  const margin = chart.constructor.MARGIN;
+  const plotWidth = chart.width - margin * 2;
+  const plotHeight = chart.height - margin * 2;
+
+  return { useZoomedArea, margin, plotWidth, plotHeight };
+}
+
+/**
+ * Build filename with optional zoom suffix
+ * @param {string} baseName - Base filename
+ * @param {boolean} isZoomed - Whether to add zoomed suffix
+ * @returns {string} Final filename
+ */
+export function buildExportFileName(baseName, isZoomed) {
+  return isZoomed ? `${baseName}_zoomed` : baseName;
+}

src/aspara/dashboard/static/js/chart/export.js

@@ -0,0 +1,140 @@
+import { buildExportFileName, calculateExportDimensions, generateCSVContent, getExportFileName } from './export-utils.js';
+
+export class ChartExport {
+  constructor(chart) {
+    this.chart = chart;
+  }
+
+  downloadData(format) {
+    if (!this.chart.data || !this.chart.data.series || this.chart.data.series.length === 0) {
+      return;
+    }
+
+    switch (format) {
+      case 'CSV':
+        this.downloadCSV();
+        break;
+      case 'SVG':
+        this.downloadSVG();
+        break;
+      case 'PNG':
+        this.downloadPNG();
+        break;
+    }
+  }
+
+  downloadCSV() {
+    const csvContent = generateCSVContent(this.chart.data.series);
+
+    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+
+    const fileName = getExportFileName(this.chart.data);
+
+    link.setAttribute('href', url);
+    link.setAttribute('download', `${fileName}.csv`);
+    link.style.display = 'none';
+
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+
+  downloadSVG() {
+    const svgNamespace = 'http://www.w3.org/2000/svg';
+    const svg = document.createElementNS(svgNamespace, 'svg');
+
+    const { useZoomedArea, margin, plotWidth, plotHeight } = calculateExportDimensions(this.chart);
+
+    if (useZoomedArea) {
+      svg.setAttribute('width', plotWidth);
+      svg.setAttribute('height', plotHeight);
+      svg.setAttribute('viewBox', `0 0 ${plotWidth} ${plotHeight}`);
+
+      const background = document.createElementNS(svgNamespace, 'rect');
+      background.setAttribute('width', plotWidth);
+      background.setAttribute('height', plotHeight);
+      background.setAttribute('fill', 'white');
+      svg.appendChild(background);
+
+      const tempCanvas = document.createElement('canvas');
+      tempCanvas.width = plotWidth;
+      tempCanvas.height = plotHeight;
+      const tempCtx = tempCanvas.getContext('2d');
+
+      tempCtx.drawImage(this.chart.canvas, margin, margin, plotWidth, plotHeight, 0, 0, plotWidth, plotHeight);
+
+      const canvasImage = document.createElementNS(svgNamespace, 'image');
+      canvasImage.setAttribute('width', plotWidth);
+      canvasImage.setAttribute('height', plotHeight);
+      canvasImage.setAttribute('href', tempCanvas.toDataURL('image/png'));
+      svg.appendChild(canvasImage);
+    } else {
+      svg.setAttribute('width', this.chart.width);
+      svg.setAttribute('height', this.chart.height);
+      svg.setAttribute('viewBox', `0 0 ${this.chart.width} ${this.chart.height}`);
+
+      const background = document.createElementNS(svgNamespace, 'rect');
+      background.setAttribute('width', this.chart.width);
+      background.setAttribute('height', this.chart.height);
+      background.setAttribute('fill', 'white');
+      svg.appendChild(background);
+
+      const canvasImage = document.createElementNS(svgNamespace, 'image');
+      canvasImage.setAttribute('width', this.chart.width);
+      canvasImage.setAttribute('height', this.chart.height);
+      canvasImage.setAttribute('href', this.chart.canvas.toDataURL('image/png'));
+      svg.appendChild(canvasImage);
+    }
+
+    const serializer = new XMLSerializer();
+    const svgString = serializer.serializeToString(svg);
+
+    const blob = new Blob([svgString], { type: 'image/svg+xml;charset=utf-8' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+
+    const fileName = buildExportFileName(getExportFileName(this.chart.data), useZoomedArea);
+
+    link.setAttribute('href', url);
+    link.setAttribute('download', `${fileName}.svg`);
+    link.style.display = 'none';
+
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+
+  downloadPNG() {
+    const { useZoomedArea, margin, plotWidth, plotHeight } = calculateExportDimensions(this.chart);
+
+    let dataURL;
+
+    if (useZoomedArea) {
+      const tempCanvas = document.createElement('canvas');
+      tempCanvas.width = plotWidth;
+      tempCanvas.height = plotHeight;
+      const tempCtx = tempCanvas.getContext('2d');
+
+      tempCtx.drawImage(this.chart.canvas, margin, margin, plotWidth, plotHeight, 0, 0, plotWidth, plotHeight);
+
+      dataURL = tempCanvas.toDataURL('image/png');
+    } else {
+      dataURL = this.chart.canvas.toDataURL('image/png');
+    }
+
+    const fileName = buildExportFileName(getExportFileName(this.chart.data), useZoomedArea);
+
+    const link = document.createElement('a');
+    link.setAttribute('href', dataURL);
+    link.setAttribute('download', `${fileName}.png`);
+    link.style.display = 'none';
+
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  }
+}