diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..f7333c8
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,64 @@
+name: CI
+
+on:
+  push:
+    branches: [master, "desktop/**", "feature/**"]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install dependencies (no heavy ML)
+        run: |
+          pip install fastapi pydantic httpx pytest pytest-asyncio sqlalchemy aiofiles
+
+      - name: Lint (ruff)
+        run: |
+          pip install ruff
+          ruff check backend/ tests/ --ignore E501
+
+      - name: Run unit tests
+        run: pytest tests/unit/ -v
+
+      - name: Run integration tests (mock pipeline)
+        run: pytest tests/integration/ -v
+
+  build-windows:
+    runs-on: windows-latest
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+          cache: pip
+
+      - name: Install build deps
+        run: pip install pyinstaller PySide6
+
+      - name: Build executable
+        run: python scripts/build_windows.py
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: AegisScoreStudio-Windows
+          path: dist/AegisScoreStudio.exe
diff --git a/.gitignore b/.gitignore
index af91fbb..fb59169 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,3 +12,8 @@ build/
 venv/
 *.log
 test_sf.wav
+aegis.db
+
+.env.local
+.setup_complete
+models/
diff --git a/AegisScore.vbs b/AegisScore.vbs
new file mode 100644
index 0000000..39982ca
--- /dev/null
+++ b/AegisScore.vbs
@@ -0,0 +1,4 @@
+Set objShell = CreateObject("WScript.Shell")
+Dim dir : dir = Left(WScript.ScriptFullName, InStrRev(WScript.ScriptFullName, "\") - 1)
+objShell.CurrentDirectory = dir
+objShell.Run "cmd /c npm start", 0, False
diff --git a/Launch Aegis.bat b/Launch Aegis.bat
new file mode 100644
index 0000000..13a7ac0
--- /dev/null
+++ b/Launch Aegis.bat	
@@ -0,0 +1,39 @@
+@echo off
+setlocal enabledelayedexpansion
+cd /d "%~dp0"
+
+:: Auto-run setup on first launch
+if not exist ".setup_complete" (
+    echo First launch detected -- running setup...
+    echo.
+    call setup.bat
+    if errorlevel 1 (
+        echo Setup failed. Please fix errors above and try again.
+        pause & exit /b 1
+    )
+)
+
+:: Load omnizart path from .env.local if present
+if exist ".env.local" (
+    for /f "tokens=1,* delims==" %%a in (.env.local) do (
+        if "%%a"=="OMNIZART_PYTHON" set OMNIZART_PYTHON=%%b
+    )
+)
+
+:: Validate omnizart path still exists (venv may have been deleted)
+if defined OMNIZART_PYTHON (
+    if not exist "!OMNIZART_PYTHON!" (
+        echo WARNING: OMNIZART_PYTHON path not found: !OMNIZART_PYTHON!
+        echo          omnizart disabled. Re-run setup.bat to reinstall.
+        set OMNIZART_PYTHON=
+    )
+)
+
+if defined OMNIZART_PYTHON (
+    echo omnizart: enabled ^(!OMNIZART_PYTHON!^)
+) else (
+    echo omnizart: disabled ^(install Python 3.9 + run setup.bat to enable^)
+)
+
+echo.
+npm start
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..03a9a51
--- /dev/null
+++ b/README.md
@@ -0,0 +1,7 @@
+download evrything as a zip.
+use ```pip install -r requirements.txt```
+also make sure u have python 3.9 installed
+have fun
+this barely works
+good luck 
+pls fix ts
diff --git a/assets/fonts/.gitkeep b/assets/fonts/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/assets/icons/.gitkeep b/assets/icons/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/assets/splash.html b/assets/splash.html
new file mode 100644
index 0000000..9099b99
--- /dev/null
+++ b/assets/splash.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8"/>
+<style>
+  * { margin:0; padding:0; box-sizing:border-box; }
+  body {
+    background:#0a0a0c;
+    display:flex; flex-direction:column;
+    align-items:center; justify-content:center;
+    height:100vh; font-family:system-ui; color:#fff;
+    user-select:none; overflow:hidden;
+  }
+  img { width:120px; height:auto; margin-bottom:16px; }
+  .title { font-size:18px; font-weight:700; letter-spacing:.05em; }
+  .sub   { font-size:11px; color:#555; margin-top:6px; }
+</style>
+</head>
+<body>
+  <img src="logo.svg" alt="" draggable="false"/>
+  <div class="title">AEGISSCORE</div>
+  <div class="sub">Starting local engine…</div>
+</body>
+</html>
diff --git a/backend/__init__.py b/backend/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/api/__init__.py b/backend/api/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/api/app.py b/backend/api/app.py
new file mode 100644
index 0000000..bd2b02f
--- /dev/null
+++ b/backend/api/app.py
@@ -0,0 +1,35 @@
+"""FastAPI app factory — same pipeline logic as web prototype, now IPC-only."""
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pathlib import Path
+
+from backend.api.routers import analyze, upload, status, midi_notes, history
+from backend.db.database import init_db
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="AegisScore-Desktop", version="0.1.0")
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:7471", "app://aegis"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    init_db()
+
+    app.include_router(analyze.router,    prefix="/api")
+    app.include_router(upload.router,     prefix="/api")
+    app.include_router(status.router,     prefix="/api")
+    app.include_router(midi_notes.router, prefix="/api")
+    app.include_router(history.router,    prefix="/api")
+
+    work_dir = Path("work")
+    work_dir.mkdir(exist_ok=True)
+    app.mount("/work", StaticFiles(directory=str(work_dir)), name="work")
+
+    return app
diff --git a/backend/api/routers/.gitkeep b/backend/api/routers/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/backend/api/routers/__init__.py b/backend/api/routers/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/api/routers/analyze.py b/backend/api/routers/analyze.py
new file mode 100644
index 0000000..fbd7c53
--- /dev/null
+++ b/backend/api/routers/analyze.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import uuid
+from fastapi import APIRouter, BackgroundTasks
+from backend.models.schemas import AnalyzeRequest, JobState, JobStatus
+from backend.services.pipeline import JOBS, URL_CACHE, pipeline_url
+
+router = APIRouter()
+
+
+@router.post("/analyze")
+async def analyze(req: AnalyzeRequest, bg: BackgroundTasks):
+    url = req.url.strip()
+    cached = URL_CACHE.get(url)
+    if cached and JOBS.get(cached, {}).get("status") == JobStatus.DONE:
+        return {"session_id": cached, "cached": True}
+    sid = str(uuid.uuid4())
+    JOBS[sid] = JobState().model_dump()
+    bg.add_task(pipeline_url, sid, url)
+    return {"session_id": sid}
diff --git a/backend/api/routers/history.py b/backend/api/routers/history.py
new file mode 100644
index 0000000..48a01aa
--- /dev/null
+++ b/backend/api/routers/history.py
@@ -0,0 +1,28 @@
+"""Session history — CRUD over SQLite."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from backend.db.database import get_db
+from backend.db.models import Session as DbSession
+
+router = APIRouter()
+
+
+@router.get("/history")
+def list_history(limit: int = 50, db: Session = Depends(get_db)):
+    rows = db.query(DbSession).order_by(DbSession.created_at.desc()).limit(limit).all()
+    return [
+        {"id": r.id, "title": r.title, "artist": r.artist, "source": r.source,
+         "duration": r.duration, "created_at": r.created_at.isoformat(),
+         "stem_count": len(r.stems)}
+        for r in rows
+    ]
+
+
+@router.delete("/history/{sid}")
+def delete_session(sid: str, db: Session = Depends(get_db)):
+    row = db.query(DbSession).filter(DbSession.id == sid).first()
+    if row:
+        db.delete(row); db.commit()
+    return {"ok": True}
diff --git a/backend/api/routers/midi_notes.py b/backend/api/routers/midi_notes.py
new file mode 100644
index 0000000..bfdbbcb
--- /dev/null
+++ b/backend/api/routers/midi_notes.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from backend.models.schemas import MidiResponse
+from backend.services.pipeline import WORK_DIR
+
+router = APIRouter()
+
+
+@router.get("/midi/{sid}/{stem_name}", response_model=MidiResponse)
+async def get_midi_notes(sid: str, stem_name: str):
+    midi_path = WORK_DIR / sid / "midi" / f"{stem_name}.mid"
+    if not midi_path.exists():
+        raise HTTPException(404, "MIDI not found")
+    import pretty_midi
+    pm = pretty_midi.PrettyMIDI(str(midi_path))
+    notes = []
+    for inst in pm.instruments:
+        for note in inst.notes:
+            notes.append({
+                "pitch": note.pitch,
+                "start": round(float(note.start), 4),
+                "end": round(float(note.end), 4),
+                "velocity": note.velocity,
+                "drum": bool(inst.is_drum),
+            })
+    notes.sort(key=lambda n: n["start"])
+    return {"notes": notes, "end_time": round(float(pm.get_end_time()), 2)}
diff --git a/backend/api/routers/status.py b/backend/api/routers/status.py
new file mode 100644
index 0000000..eedc7ab
--- /dev/null
+++ b/backend/api/routers/status.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse
+from backend.services.pipeline import JOBS
+
+router = APIRouter()
+
+
+@router.get("/status/{sid}")
+async def status(sid: str):
+    job = JOBS.get(sid)
+    if not job:
+        raise HTTPException(404, "session not found")
+    return JSONResponse(job)
diff --git a/backend/api/routers/upload.py b/backend/api/routers/upload.py
new file mode 100644
index 0000000..1d9048f
--- /dev/null
+++ b/backend/api/routers/upload.py
@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+from fastapi import APIRouter, BackgroundTasks, UploadFile, File
+from backend.models.schemas import JobState
+from backend.services.pipeline import JOBS, WORK_DIR, pipeline_file
+
+router = APIRouter()
+
+
+@router.post("/upload")
+async def upload(bg: BackgroundTasks, file: UploadFile = File(...)):
+    sid = str(uuid.uuid4())
+    job_dir = WORK_DIR / sid
+    job_dir.mkdir(parents=True, exist_ok=True)
+    suffix = Path(file.filename or "audio.wav").suffix or ".wav"
+    dest = job_dir / f"audio{suffix}"
+    dest.write_bytes(await file.read())
+    JOBS[sid] = JobState().model_dump()
+    bg.add_task(pipeline_file, sid, dest, file.filename or "audio")
+    return {"session_id": sid}
diff --git a/backend/bridge.py b/backend/bridge.py
new file mode 100644
index 0000000..4944362
--- /dev/null
+++ b/backend/bridge.py
@@ -0,0 +1,118 @@
+"""
+AppBridge — Qt object exposed to QML via setContextProperty.
+QML calls methods here; signals fire back to QML reactively.
+All heavy work delegated to FastAPI backend via HTTP (localhost).
+"""
+from __future__ import annotations
+
+import json
+import urllib.request
+import urllib.parse
+from PySide6.QtCore import QObject, Signal, Slot, Property, QTimer
+
+
+BACKEND = "http://127.0.0.1:7471"
+
+
+def _post(path: str, payload: dict) -> dict:
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request(
+        BACKEND + path, data=data,
+        headers={"Content-Type": "application/json"}, method="POST"
+    )
+    with urllib.request.urlopen(req, timeout=10) as r:
+        return json.loads(r.read())
+
+
+def _get(path: str) -> dict:
+    with urllib.request.urlopen(BACKEND + path, timeout=10) as r:
+        return json.loads(r.read())
+
+
+class AppBridge(QObject):
+    # Signals → QML
+    sessionStarted  = Signal(str)           # session_id
+    progressChanged = Signal(float, int, str)  # progress, stage, status
+    analysisReady   = Signal("QVariant")    # full job dict
+    errorOccurred   = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._sid: str | None = None
+        self._poll_timer = QTimer(self)
+        self._poll_timer.setInterval(800)
+        self._poll_timer.timeout.connect(self._poll)
+
+    # ── QML-callable slots ────────────────────────────────────────────────────
+
+    @Slot(str)
+    def analyzeUrl(self, url: str) -> None:
+        try:
+            resp = _post("/api/analyze", {"url": url.strip()})
+            self._sid = resp["session_id"]
+            self.sessionStarted.emit(self._sid)
+            self._poll_timer.start()
+        except Exception as e:
+            self.errorOccurred.emit(str(e))
+
+    @Slot(str)
+    def openLocalFile(self, path: str) -> None:
+        """QML passes native file path; bridge uploads to backend."""
+        import urllib.request
+        # multipart upload
+        boundary = "AegisBoundary42"
+        with open(path, "rb") as f:
+            file_data = f.read()
+        filename = path.split("/")[-1].split("\\")[-1]
+        body = (
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"file\"; "
+            f"filename=\"{filename}\"\r\nContent-Type: application/octet-stream\r\n\r\n"
+        ).encode() + file_data + f"\r\n--{boundary}--\r\n".encode()
+        req = urllib.request.Request(
+            BACKEND + "/api/upload", data=body,
+            headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=30) as r:
+                resp = json.loads(r.read())
+            self._sid = resp["session_id"]
+            self.sessionStarted.emit(self._sid)
+            self._poll_timer.start()
+        except Exception as e:
+            self.errorOccurred.emit(str(e))
+
+    @Slot(str, str, result="QVariant")
+    def getMidiNotes(self, sid: str, stem_id: str) -> dict:
+        try:
+            return _get(f"/api/midi/{sid}/{stem_id}")
+        except Exception:
+            return {"notes": [], "end_time": 0.0}
+
+    @Slot()
+    def cancelSession(self) -> None:
+        self._poll_timer.stop()
+        self._sid = None
+
+    # ── Polling ───────────────────────────────────────────────────────────────
+
+    def _poll(self) -> None:
+        if not self._sid:
+            self._poll_timer.stop()
+            return
+        try:
+            job = _get(f"/api/status/{self._sid}")
+        except Exception:
+            return
+        self.progressChanged.emit(
+            job.get("progress", 0.0),
+            job.get("stage", -1),
+            job.get("status", ""),
+        )
+        if job.get("status") in ("done", "error"):
+            self._poll_timer.stop()
+            if job["status"] == "done":
+                job["session_id"] = self._sid
+                self.analysisReady.emit(job)
+            else:
+                self.errorOccurred.emit(job.get("error") or "Unknown error")
diff --git a/backend/db/__init__.py b/backend/db/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/db/database.py b/backend/db/database.py
new file mode 100644
index 0000000..d90c3da
--- /dev/null
+++ b/backend/db/database.py
@@ -0,0 +1,23 @@
+"""DB engine + session factory."""
+from __future__ import annotations
+
+from pathlib import Path
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from backend.db.models import Base
+
+DB_PATH = Path("aegis.db")
+_ENGINE = create_engine(f"sqlite:///{DB_PATH}", connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(bind=_ENGINE, autocommit=False, autoflush=False)
+
+
+def init_db() -> None:
+    Base.metadata.create_all(bind=_ENGINE)
+
+
+def get_db():
+    db: Session = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
diff --git a/backend/db/models.py b/backend/db/models.py
new file mode 100644
index 0000000..e903210
--- /dev/null
+++ b/backend/db/models.py
@@ -0,0 +1,48 @@
+"""SQLAlchemy 2.x ORM models."""
+from __future__ import annotations
+
+from datetime import datetime
+from sqlalchemy import String, Float, Integer, Boolean, ForeignKey, DateTime, JSON
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Session(Base):
+    __tablename__ = "sessions"
+
+    id:         Mapped[str]      = mapped_column(String(36), primary_key=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+    source:     Mapped[str]      = mapped_column(String(2048))
+    title:      Mapped[str]      = mapped_column(String(512), default="")
+    artist:     Mapped[str]      = mapped_column(String(512), default="")
+    duration:   Mapped[float]    = mapped_column(Float, default=0.0)
+    thumb:      Mapped[str]      = mapped_column(String(2048), default="")
+    tempo:      Mapped[int]      = mapped_column(Integer, default=120)
+    key:        Mapped[str]      = mapped_column(String(32), default="A minor")
+    time_sig:   Mapped[list]     = mapped_column(JSON, default=lambda: [4, 4])
+    status:     Mapped[str]      = mapped_column(String(32), default="done")
+
+    stems: Mapped[list[Stem]] = relationship("Stem", back_populates="session", cascade="all, delete-orphan")
+
+
+class Stem(Base):
+    __tablename__ = "stems"
+
+    id:          Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    session_id:  Mapped[str] = mapped_column(String(36), ForeignKey("sessions.id"))
+    stem_id:     Mapped[str] = mapped_column(String(32))   # "drums", "bass", …
+    name:        Mapped[str] = mapped_column(String(128))
+    instrument:  Mapped[str] = mapped_column(String(256))
+    clef:        Mapped[str] = mapped_column(String(16))
+    color:       Mapped[str] = mapped_column(String(32))
+    role:        Mapped[str] = mapped_column(String(64))
+    confidence:  Mapped[float] = mapped_column(Float)
+    midi_count:  Mapped[int]   = mapped_column(Integer, default=0)
+    audio_path:  Mapped[str]   = mapped_column(String(1024), default="")
+    midi_path:   Mapped[str]   = mapped_column(String(1024), default="")
+    muted:       Mapped[bool]  = mapped_column(Boolean, default=False)
+
+    session: Mapped[Session] = relationship("Session", back_populates="stems")
diff --git a/backend/models/.gitkeep b/backend/models/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/backend/models/__init__.py b/backend/models/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/models/schemas.py b/backend/models/schemas.py
new file mode 100644
index 0000000..e7bac27
--- /dev/null
+++ b/backend/models/schemas.py
@@ -0,0 +1,84 @@
+"""Pydantic v2 schemas — shared contracts between FastAPI and QML bridge."""
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Any
+from pydantic import BaseModel, Field
+
+
+class JobStatus(StrEnum):
+    QUEUED      = "queued"
+    DOWNLOADING = "downloading"
+    CONVERTING  = "converting"
+    SEPARATING  = "separating"
+    IDENTIFYING = "identifying"
+    TRANSCRIBING= "transcribing"
+    ENGRAVING   = "engraving"
+    DONE        = "done"
+    ERROR       = "error"
+
+
+class GpuInfo(BaseModel):
+    model: str = "CPU"
+    util: float = 0.0
+    vram: float = 0.0
+    vram_total: float = 0.0
+
+
+class StemSchema(BaseModel):
+    id: str
+    name: str
+    instrument: str
+    family: str
+    clef: str
+    color: str
+    role: str
+    confidence: float
+    midi: int
+    audio_url: str
+    midi_url: str | None
+    density: int = 2
+    seed: int = 0
+    note: str = ""
+
+
+class JobMeta(BaseModel):
+    title: str = ""
+    artist: str = ""
+    duration: float = 0.0
+    thumb: str = ""
+    source: str = ""
+    tempo: int = 120
+    key: str = "A minor"
+    time_sig: list[int] = Field(default_factory=lambda: [4, 4])
+    sample_rate: int = 44100
+    bit_depth: int = 24
+    sep_model: str = ""
+    trans_model: str = ""
+    gpu: GpuInfo = Field(default_factory=GpuInfo)
+
+
+class JobState(BaseModel):
+    status: JobStatus = JobStatus.QUEUED
+    progress: float = 0.0
+    stage: int = -1
+    meta: JobMeta = Field(default_factory=JobMeta)
+    stems: list[StemSchema] = Field(default_factory=list)
+    error: str | None = None
+
+
+class AnalyzeRequest(BaseModel):
+    url: str
+
+
+class MidiNote(BaseModel):
+    pitch: int
+    start: float
+    end: float
+    velocity: int
+    drum: bool
+
+
+class MidiResponse(BaseModel):
+    notes: list[MidiNote]
+    end_time: float
diff --git a/backend/services/.gitkeep b/backend/services/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/backend/services/__init__.py b/backend/services/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/services/pipeline.py b/backend/services/pipeline.py
new file mode 100644
index 0000000..6ad7337
--- /dev/null
+++ b/backend/services/pipeline.py
@@ -0,0 +1,187 @@
+"""
+Core audio pipeline — same logic as web prototype server.py,
+now as a proper service module with typed state.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+WORK_DIR = Path("work")
+WORK_DIR.mkdir(exist_ok=True)
+
+URL_CACHE: dict[str, str] = {}
+JOBS: dict[str, dict] = {}
+
+DEMUCS_SOURCES = ["drums", "bass", "other", "vocals", "guitar", "piano"]
+
+STEM_META = {
+    "drums":  {"name": "Drums",  "instrument": "Acoustic Kit",           "family": "Percussion · GM 0", "clef": "perc",   "color": "--s-drums",  "role": "Rhythm"},
+    "bass":   {"name": "Bass",   "instrument": "Electric Bass (finger)",  "family": "Bass · GM 33",      "clef": "bass",   "color": "--s-bass",   "role": "Low end"},
+    "guitar": {"name": "Guitar", "instrument": "Electric Guitar",         "family": "Guitar · GM 27",    "clef": "treble", "color": "--s-guitar", "role": "Harmony"},
+    "piano":  {"name": "Piano",  "instrument": "Grand Piano",             "family": "Piano · GM 0",      "clef": "treble", "color": "--s-keys",   "role": "Keys"},
+    "vocals": {"name": "Vocals", "instrument": "Lead Vocal",              "family": "Voice",             "clef": "treble", "color": "--s-vocal",  "role": "Melody"},
+    "other":  {"name": "Other",  "instrument": "Mixed / Other",           "family": "Synth",             "clef": "treble", "color": "--s-synth",  "role": "Texture"},
+}
+
+_POOL = ThreadPoolExecutor(max_workers=min(6, (os.cpu_count() or 2)))
+_DEVICE = "cuda" if __import__("torch").cuda.is_available() else "cpu"
+
+
+def _set(sid: str, **kwargs: object) -> None:
+    JOBS[sid].update(kwargs)
+
+
+async def _run_async(cmd: list[str]) -> None:
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    _, stderr = await proc.communicate()
+    if proc.returncode != 0:
+        detail = (stderr or b"no output").decode(errors="replace")[-2000:]
+        raise RuntimeError(f"Command failed (exit {proc.returncode}):\n{detail}")
+
+
+def _transcribe_stem_sync(wav_path: Path, midi_out: Path, is_drums: bool) -> int:
+    import librosa, numpy as np, pretty_midi
+    SR, HOP = 22050, 1024
+    y, sr = librosa.load(str(wav_path), sr=SR, mono=True, duration=300)
+    pm = pretty_midi.PrettyMIDI()
+    if is_drums:
+        drum = pretty_midi.Instrument(program=0, is_drum=True)
+        onset_frames = librosa.onset.onset_detect(y=y, sr=sr, units="frames", backtrack=True, hop_length=HOP)
+        for i, t in enumerate(librosa.frames_to_time(onset_frames, sr=sr, hop_length=HOP)):
+            drum.notes.append(pretty_midi.Note(velocity=90, pitch=36 if i%2==0 else 38, start=float(t), end=float(t)+0.05))
+        pm.instruments.append(drum); pm.write(str(midi_out)); return len(drum.notes)
+    f0, voiced_flag, _ = librosa.pyin(y, fmin=librosa.note_to_hz("C2"), fmax=librosa.note_to_hz("C7"), sr=sr, frame_length=2048, hop_length=HOP)
+    times = librosa.times_like(f0, sr=sr, hop_length=HOP)
+    inst = pretty_midi.Instrument(program=0); in_note = False; note_start = 0.0; note_pitch = 0
+    for t, freq, voiced in zip(times, f0, voiced_flag):
+        if voiced and not np.isnan(freq):
+            mp = max(0, min(127, int(round(librosa.hz_to_midi(freq)))))
+            if not in_note: in_note, note_start, note_pitch = True, float(t), mp
+            elif mp != note_pitch:
+                if float(t)-note_start >= 0.05: inst.notes.append(pretty_midi.Note(velocity=80, pitch=note_pitch, start=note_start, end=float(t)))
+                note_start, note_pitch = float(t), mp
+        elif in_note:
+            if float(t)-note_start >= 0.05: inst.notes.append(pretty_midi.Note(velocity=80, pitch=note_pitch, start=note_start, end=float(t)))
+            in_note = False
+    pm.instruments.append(inst); pm.write(str(midi_out)); return len(inst.notes)
+
+
+def _gpu_info() -> dict:
+    try:
+        import torch
+        if torch.cuda.is_available():
+            name = torch.cuda.get_device_name(0)
+            vram = torch.cuda.get_device_properties(0).total_memory / 1024**3
+            return {"model": name, "util": 0, "vram": round(vram, 1), "vramTotal": round(vram, 1)}
+    except Exception:
+        pass
+    return {"model": "CPU", "util": 0, "vram": 0, "vramTotal": 0}
+
+
+async def _separate_and_transcribe(sid: str, audio_path: Path, meta: dict) -> None:
+    job_dir = audio_path.parent
+    stems_dir = job_dir / "stems"; stems_dir.mkdir(exist_ok=True)
+    midi_dir  = job_dir / "midi";  midi_dir.mkdir(exist_ok=True)
+
+    _set(sid, stage=1, status="separating", progress=0.20)
+    await _run_async([sys.executable, "-m", "demucs", "--name", "htdemucs_6s", "--device", _DEVICE, "--out", str(job_dir / "demucs_out"), str(audio_path)])
+    demucs_root = next((job_dir / "demucs_out" / "htdemucs_6s").iterdir())
+    for stem_wav in demucs_root.glob("*.wav"):
+        shutil.copy(stem_wav, stems_dir / stem_wav.name)
+    _set(sid, progress=0.62)
+
+    _set(sid, stage=2, status="identifying", progress=0.64)
+    _set(sid, progress=0.70)
+
+    _set(sid, stage=3, status="transcribing", progress=0.72)
+    loop = asyncio.get_event_loop()
+    tasks, stem_names = [], []
+    for stem_name in DEMUCS_SOURCES:
+        stem_file = stems_dir / f"{stem_name}.wav"
+        if not stem_file.exists(): continue
+        tasks.append(loop.run_in_executor(_POOL, _transcribe_stem_sync, stem_file, midi_dir / f"{stem_name}.mid", stem_name == "drums"))
+        stem_names.append(stem_name)
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    midi_counts = {n: (r if isinstance(r, int) else 0) for n, r in zip(stem_names, results)}
+    _set(sid, progress=0.90)
+
+    _set(sid, stage=4, status="engraving", progress=0.95)
+
+    stems = []
+    for name in DEMUCS_SOURCES:
+        if not (stems_dir / f"{name}.wav").exists(): continue
+        m = STEM_META.get(name, {})
+        stems.append({
+            "id": name, "name": m.get("name", name.title()),
+            "instrument": m.get("instrument", "Unknown"),
+            "family": m.get("family", ""), "clef": m.get("clef", "treble"),
+            "color": m.get("color", "--s-synth"), "role": m.get("role", ""),
+            "confidence": 90.0, "midi": midi_counts.get(name, 0),
+            "audio_url": f"/work/{sid}/stems/{name}.wav",
+            "midi_url": f"/work/{sid}/midi/{name}.mid" if (midi_dir / f"{name}.mid").exists() else None,
+            "density": 2, "seed": abs(hash(name)) % 50000, "note": "",
+        })
+
+    _set(sid, status="done", progress=1.0, stage=4, stems=stems,
+         meta={**meta, "tempo": 120, "key": "A minor", "timeSig": [4, 4],
+               "sampleRate": 44100, "bitDepth": 24,
+               "sepModel": "HT-Demucs v4 · 6-stem", "transModel": "librosa-pyin",
+               "gpu": _gpu_info()})
+
+
+async def pipeline_url(sid: str, url: str) -> None:
+    job_dir = WORK_DIR / sid; job_dir.mkdir(parents=True, exist_ok=True)
+    audio_path = job_dir / "audio.wav"
+    try:
+        _set(sid, stage=0, status="downloading", progress=0.0)
+        import yt_dlp
+        ydl_opts = {
+            "format": "bestaudio[ext=webm]/bestaudio[ext=m4a]/bestaudio/best",
+            "postprocessors": [{"key": "FFmpegExtractAudio", "preferredcodec": "wav", "preferredquality": "0"}],
+            "outtmpl": str(job_dir / "audio"),
+            "quiet": True, "no_warnings": True,
+            "extractor_args": {"youtube": {"player_client": ["android", "web"]}},
+        }
+        loop = asyncio.get_event_loop()
+        def _dl():
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl: return ydl.extract_info(url, download=True)
+        info = await loop.run_in_executor(None, _dl)
+        meta = {"title": info.get("title","Unknown"), "artist": info.get("uploader","Unknown"),
+                "duration": info.get("duration",0), "thumb": info.get("thumbnail",""), "source": url}
+        candidates = [audio_path]+sorted(job_dir.glob("audio.*"), key=lambda p: p.stat().st_mtime, reverse=True)
+        resolved = next((p for p in candidates if p.exists() and p.suffix==".wav"), None)
+        if resolved and resolved != audio_path: resolved.rename(audio_path)
+        elif not resolved: raise FileNotFoundError("yt-dlp produced no WAV")
+        _set(sid, meta=meta, progress=0.18)
+        await _separate_and_transcribe(sid, audio_path, meta)
+        URL_CACHE[url] = sid
+        from backend.services.session_store import save_session
+        save_session(sid, JOBS[sid])
+    except Exception as exc:
+        _set(sid, status="error", error=str(exc), progress=1.0)
+
+
+async def pipeline_file(sid: str, audio_path: Path, filename: str) -> None:
+    try:
+        _set(sid, stage=0, status="converting", progress=0.05)
+        if audio_path.suffix.lower() != ".wav":
+            wav_path = audio_path.with_suffix(".wav")
+            await _run_async(["ffmpeg", "-y", "-i", str(audio_path), "-ac", "2", "-ar", "44100", str(wav_path)])
+            audio_path.unlink(missing_ok=True)
+            audio_path = wav_path
+        import soundfile as sf
+        info = sf.info(str(audio_path))
+        meta = {"title": Path(filename).stem, "artist": "Local file", "duration": int(info.duration), "thumb": "", "source": filename}
+        _set(sid, meta=meta, progress=0.18)
+        await _separate_and_transcribe(sid, audio_path, meta)
+        from backend.services.session_store import save_session
+        save_session(sid, JOBS[sid])
+    except Exception as exc:
+        _set(sid, status="error", error=str(exc), progress=1.0)
diff --git a/backend/services/session_store.py b/backend/services/session_store.py
new file mode 100644
index 0000000..c192979
--- /dev/null
+++ b/backend/services/session_store.py
@@ -0,0 +1,42 @@
+"""Persist a completed pipeline job to SQLite."""
+from __future__ import annotations
+
+from backend.db.database import SessionLocal
+from backend.db.models import Session as DbSession, Stem as DbStem
+
+
+def save_session(sid: str, job: dict) -> None:
+    meta = job.get("meta", {})
+    db = SessionLocal()
+    try:
+        existing = db.query(DbSession).filter(DbSession.id == sid).first()
+        if existing:
+            return
+        row = DbSession(
+            id=sid,
+            source=meta.get("source", ""),
+            title=meta.get("title", ""),
+            artist=meta.get("artist", ""),
+            duration=meta.get("duration", 0.0),
+            thumb=meta.get("thumb", ""),
+            tempo=meta.get("tempo", 120),
+            key=meta.get("key", "A minor"),
+            time_sig=meta.get("timeSig", [4, 4]),
+            status="done",
+        )
+        for s in job.get("stems", []):
+            row.stems.append(DbStem(
+                stem_id=s.get("id", ""),
+                name=s.get("name", ""),
+                instrument=s.get("instrument", ""),
+                clef=s.get("clef", "treble"),
+                color=s.get("color", ""),
+                role=s.get("role", ""),
+                confidence=s.get("confidence", 0.0),
+                midi_count=s.get("midi", 0),
+                audio_path=s.get("audio_url", ""),
+                midi_path=s.get("midi_url", "") or "",
+            ))
+        db.add(row); db.commit()
+    finally:
+        db.close()
diff --git a/build.bat b/build.bat
new file mode 100644
index 0000000..b77f2fc
--- /dev/null
+++ b/build.bat
@@ -0,0 +1,21 @@
+@echo off
+cd /d "%~dp0"
+
+echo [1/3] Checking PyInstaller...
+python -m PyInstaller --version >nul 2>&1
+if errorlevel 1 (
+    echo Installing PyInstaller...
+    pip install pyinstaller
+)
+
+echo [2/3] Bundling Python server...
+python -m PyInstaller server_launch.spec --noconfirm --distpath dist
+if errorlevel 1 ( echo PyInstaller failed & pause & exit /b 1 )
+
+echo [3/3] Building Electron installer...
+npm run build
+if errorlevel 1 ( echo electron-builder failed & pause & exit /b 1 )
+
+echo.
+echo Done! Installer is in dist\
+pause
diff --git a/build.py b/build.py
new file mode 100644
index 0000000..8312406
--- /dev/null
+++ b/build.py
@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Aegis Score Studio — build script
+Produces: dist/Aegis Score Studio Setup.exe  (Windows NSIS installer)
+
+Usage:
+  python build.py          # full build (PyInstaller server + Electron installer)
+  python build.py --electron-only  # skip PyInstaller, requires Python on target
+
+Steps:
+  1. Verify / fix setuptools so PyInstaller works
+  2. PyInstaller: server_launch.py -> dist/server_dist/server_launch.exe
+  3. electron-builder: bundles Electron + server_dist -> dist/*.exe installer
+"""
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parent.resolve()
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def run(cmd, **kwargs):
+    cmd_str = " ".join(str(c) for c in cmd)
+    print(f"\n>>> {cmd_str}")
+    subprocess.run(cmd, check=True, **kwargs)
+
+
+def run_py(*args):
+    run([sys.executable, *args])
+
+
+# ── Step 1: Fix setuptools / pkg_resources ────────────────────────────────────
+
+def ensure_pyinstaller():
+    # setuptools >= 80 dropped pkg_resources; PyInstaller (via altgraph) needs it
+    try:
+        import pkg_resources  # noqa: F401
+        import PyInstaller    # noqa: F401
+        print("[1] setuptools + PyInstaller OK")
+        return
+    except ModuleNotFoundError:
+        pass
+
+    print("[1] Fixing setuptools (pinning <80 for pkg_resources) ...")
+    run_py("-m", "pip", "install", "setuptools<80", "--quiet")
+    print("[1] Installing / upgrading PyInstaller ...")
+    run_py("-m", "pip", "install", "pyinstaller", "--upgrade", "--quiet")
+    print("[1] Done.")
+
+
+# ── Step 2: PyInstaller ───────────────────────────────────────────────────────
+
+HIDDEN = [
+    # uvicorn lazy imports
+    "uvicorn.logging",
+    "uvicorn.loops", "uvicorn.loops.auto",
+    "uvicorn.protocols", "uvicorn.protocols.http",
+    "uvicorn.protocols.http.auto",
+    "uvicorn.protocols.http.httptools_impl",
+    "uvicorn.protocols.http.h11_impl",
+    "uvicorn.protocols.websockets",
+    "uvicorn.protocols.websockets.auto",
+    "uvicorn.protocols.websockets.wsproto_impl",
+    "uvicorn.lifespan", "uvicorn.lifespan.on", "uvicorn.lifespan.off",
+    # starlette / fastapi
+    "starlette", "starlette.staticfiles", "starlette.routing",
+    "starlette.middleware", "starlette.responses",
+    # audio + ML
+    "librosa", "librosa.core", "librosa.feature", "librosa.beat",
+    "librosa.onset", "librosa.decompose", "librosa.effects",
+    "pretty_midi", "soundfile", "yt_dlp",
+    "demucs", "demucs.pretrained", "demucs.apply", "demucs.audio",
+    "torchaudio", "torch", "sklearn",
+    "scipy", "scipy.signal", "scipy.ndimage",
+]
+
+COLLECT_ALL = ["librosa", "demucs", "torchaudio", "yt_dlp"]
+
+STATIC_DATA = [
+    ("index.html", "."),
+    ("css",        "css"),
+    ("js",         "js"),
+    ("assets",     "assets"),
+]
+
+
+def _data_flag(src, dst):
+    sep = ";" if sys.platform == "win32" else ":"
+    return f"--add-data={src}{sep}{dst}"
+
+
+def build_server_exe():
+    print("[2] Building server_launch.exe with PyInstaller ...")
+    out_dir = ROOT / "dist" / "server_dist"
+
+    cmd = [
+        sys.executable, "-m", "PyInstaller",
+        "--noconfirm",
+        "--onedir",
+        "--name",    "server_launch",
+        "--distpath", str(ROOT / "dist"),
+        "--workpath", str(ROOT / "build_pyinstaller"),
+        "--specpath", str(ROOT),
+        "--noconsole",             # no shell window — Electron reads stdout/stderr via pipe
+    ]
+
+    for h in HIDDEN:
+        cmd += ["--hidden-import", h]
+
+    for pkg in COLLECT_ALL:
+        cmd += ["--collect-all", pkg]
+
+    for src, dst in STATIC_DATA:
+        p = ROOT / src
+        if p.exists():
+            cmd.append(_data_flag(str(p), dst))
+        else:
+            print(f"  [warn] skipping missing: {src}")
+
+    cmd.append(str(ROOT / "server_launch.py"))
+    run(cmd, cwd=ROOT)
+    print(f"[2] server_launch.exe → {out_dir}")
+
+
+# ── Step 3: Update package.json extraResources ────────────────────────────────
+
+def patch_package_json():
+    print("[3] Patching package.json extraResources ...")
+    pkg_path = ROOT / "package.json"
+    pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+
+    pkg.setdefault("build", {})
+    pkg["build"]["extraResources"] = [
+        {
+            "from": "dist/server_dist",
+            "to":   "server_dist",
+            "filter": ["**/*"]
+        }
+    ]
+
+    # Ensure icon path exists or drop it
+    win_cfg = pkg["build"].get("win", {})
+    icon_path = ROOT / win_cfg.get("icon", "NONE")
+    if not icon_path.exists():
+        print(f"  [warn] icon not found ({icon_path.name}) — removing from config")
+        win_cfg.pop("icon", None)
+        pkg["build"]["win"] = win_cfg
+
+    pkg_path.write_text(json.dumps(pkg, indent=2), encoding="utf-8")
+    print("[3] Done.")
+
+
+# ── Step 4: electron-builder ──────────────────────────────────────────────────
+
+def build_electron():
+    print("[4] Running electron-builder ...")
+    # npm is a .cmd on Windows
+    npm = "npm.cmd" if sys.platform == "win32" else "npm"
+    run([npm, "run", "build"], cwd=ROOT)
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Build Aegis Score Studio")
+    parser.add_argument("--electron-only", action="store_true",
+                        help="Skip PyInstaller — target machine needs Python installed")
+    args = parser.parse_args()
+
+    print("=" * 62)
+    print("  Aegis Score Studio — Build Script")
+    print("=" * 62)
+
+    if args.electron_only:
+        print("\n[MODE] electron-only (Python required on target)")
+        pkg_path = ROOT / "package.json"
+        pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+        pkg["build"].pop("extraResources", None)
+        pkg_path.write_text(json.dumps(pkg, indent=2), encoding="utf-8")
+        build_electron()
+    else:
+        print("\n[MODE] full (self-contained — bundles Python + all deps)")
+        print("       Expected output size: 2–4 GB (torch + demucs + librosa)\n")
+        ensure_pyinstaller()
+        build_server_exe()
+        patch_package_json()
+        build_electron()
+
+    dist = ROOT / "dist"
+    installer = next(dist.glob("*.exe"), None)
+    if installer:
+        size_mb = installer.stat().st_size / 1024 / 1024
+        print(f"\n{'='*62}")
+        print(f"  Done!  {installer.name}  ({size_mb:.0f} MB)")
+        print(f"  Path:  {installer}")
+        print(f"{'='*62}")
+    else:
+        print(f"\nBuild complete. Output in: {dist}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/core/__init__.py b/core/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/core/audio/.gitkeep b/core/audio/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/core/midi/.gitkeep b/core/midi/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/core/notation/.gitkeep b/core/notation/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/css/app.css b/css/app.css
index 4e87810..0157325 100644
--- a/css/app.css
+++ b/css/app.css
@@ -284,6 +284,8 @@ html, body {
 .crumbs { display: flex; align-items: center; gap: 7px; color: var(--t-2); }
 .crumbs b { color: var(--t-0); font-weight: 600; }
 .crumbs .sep { color: var(--t-3); }
+#crumb-title:not(:empty) { cursor: pointer; border-radius: 4px; padding: 1px 4px; transition: background var(--t-micro); }
+#crumb-title:not(:empty):hover { background: var(--bg-3); }
 .crumbs .dot { width: 7px; height: 7px; border-radius: 50%; background: var(--good); box-shadow: 0 0 8px var(--good); }
 
 .pill {
@@ -473,6 +475,8 @@ html, body {
 }
 .tbtn svg { width: 14px; height: 14px; }
 .tbtn.play svg { width: 13px; height: 13px; }
+.tp-mode-btn { width: auto; padding: 0 8px; font-size: 10px; font-weight: 700; font-family: var(--mono); letter-spacing: .04em; }
+.tp-mode-btn.on { background: var(--acc); border-color: var(--acc-bright); color: var(--bg-0); }
 
 .timecode {
   display: flex; align-items: baseline; gap: 2px;
@@ -775,7 +779,7 @@ html, body {
    CONTEXT MENU
    ============================================================ */
 .ctx {
-  position: fixed; z-index: 200; min-width: 210px;
+  position: fixed; z-index: 700; min-width: 210px;
   background: oklch(0.20 0.008 258 / 0.92);
   backdrop-filter: blur(16px) saturate(1.4);
   -webkit-backdrop-filter: blur(16px) saturate(1.4);
diff --git a/frontend/qml/components/.gitkeep b/frontend/qml/components/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/frontend/qml/components/FlashToast.qml b/frontend/qml/components/FlashToast.qml
new file mode 100644
index 0000000..8b94ec7
--- /dev/null
+++ b/frontend/qml/components/FlashToast.qml
@@ -0,0 +1,32 @@
+import QtQuick 2.15
+
+Rectangle {
+    id: root
+    property string message: ""
+
+    width: toastText.implicitWidth + 32
+    height: 36; radius: 8
+    color: "#1e2d4a"
+    border.color: "#2d4a7a"
+    opacity: 0
+    visible: opacity > 0
+
+    Text {
+        id: toastText
+        anchors.centerIn: parent
+        text: root.message
+        color: "#e2e8f0"; font.pixelSize: 13
+    }
+
+    function show(msg) {
+        message = msg
+        showAnim.restart()
+    }
+
+    SequentialAnimation {
+        id: showAnim
+        NumberAnimation { target: root; property: "opacity"; to: 1.0; duration: 160; easing.type: Easing.OutQuad }
+        PauseAnimation { duration: 2000 }
+        NumberAnimation { target: root; property: "opacity"; to: 0.0; duration: 300; easing.type: Easing.InQuad }
+    }
+}
diff --git a/frontend/qml/components/Inspector.qml b/frontend/qml/components/Inspector.qml
new file mode 100644
index 0000000..3eeae48
--- /dev/null
+++ b/frontend/qml/components/Inspector.qml
@@ -0,0 +1,170 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+
+Rectangle {
+    id: root
+    property var    job: null
+    property string sessionId: ""
+    signal exportMidi()
+    signal exportWav()
+    color: "#090d18"
+
+    Column {
+        anchors { top: parent.top; left: parent.left; right: parent.right; topMargin: 0 }
+        spacing: 0
+
+        // Header
+        Rectangle {
+            width: parent.width; height: 36; color: "#0d1220"
+            Text { anchors { verticalCenter: parent.verticalCenter; left: parent.left; leftMargin: 16 }
+                   text: "INSPECTOR"; color: "#334155"; font.pixelSize: 10; font.letterSpacing: 1.5 }
+        }
+
+        // Song info
+        Rectangle {
+            width: parent.width
+            height: infoCol.implicitHeight + 24
+            color: "transparent"
+            Column {
+                id: infoCol
+                anchors { left: parent.left; right: parent.right; top: parent.top; margins: 16 }
+                spacing: 6
+                Text { text: job ? job.meta.title  : "No project"; color: "#e2e8f0"; font.pixelSize: 15; font.weight: Font.Medium; wrapMode: Text.WordWrap; width: parent.width }
+                Text { text: job ? job.meta.artist : "";            color: "#64748b"; font.pixelSize: 12 }
+                Text { text: job ? job.meta.sepModel : "";          color: "#334155"; font.pixelSize: 10 }
+            }
+        }
+
+        Rectangle { width: parent.width; height: 1; color: "#131c2e" }
+
+        // Metrics
+        Rectangle {
+            width: parent.width; height: metricsCol.implicitHeight + 20; color: "transparent"
+            Column {
+                id: metricsCol
+                anchors { left: parent.left; right: parent.right; top: parent.top; margins: 16 }
+                spacing: 10
+                _MetricRow { label: "Tempo";   value: job ? job.meta.tempo + " BPM" : "—" }
+                _MetricRow { label: "Key";     value: job ? job.meta.key : "—" }
+                _MetricRow { label: "Time";    value: job ? (job.meta.timeSig ? job.meta.timeSig[0]+"/"+job.meta.timeSig[1] : "4/4") : "—" }
+                _MetricRow { label: "Duration";value: job ? _fmtTime(job.meta.duration) : "—" }
+                _MetricRow { label: "Stems";   value: job ? job.stems.length : "0" }
+                _MetricRow { label: "MIDI";    value: job ? job.stems.reduce(function(a,s){return a+s.midi},0).toLocaleString() : "0" }
+            }
+        }
+
+        Rectangle { width: parent.width; height: 1; color: "#131c2e" }
+
+        // GPU
+        Rectangle {
+            width: parent.width; height: gpuCol.implicitHeight + 20; color: "transparent"
+            Column {
+                id: gpuCol
+                anchors { left: parent.left; right: parent.right; top: parent.top; margins: 16 }
+                spacing: 10
+                Text { text: "GPU / CPU"; color: "#475569"; font.pixelSize: 10; font.letterSpacing: 1 }
+                Text { text: job ? job.meta.gpu.model : "—"; color: "#94a3b8"; font.pixelSize: 12 }
+                // VRAM bar
+                Rectangle {
+                    width: parent.width; height: 4; radius: 2; color: "#1e2535"
+                    visible: job && job.meta.gpu.vramTotal > 0
+                    Rectangle {
+                        width: job ? (job.meta.gpu.vramTotal > 0 ? parent.width * job.meta.gpu.vram / job.meta.gpu.vramTotal : 0) : 0
+                        height: parent.height; radius: 2; color: "#3b82f6"
+                    }
+                }
+                Text { text: job && job.meta.gpu.vramTotal > 0 ? job.meta.gpu.vram.toFixed(1) + " / " + job.meta.gpu.vramTotal.toFixed(1) + " GB" : "CPU-only"; color: "#64748b"; font.pixelSize: 10 }
+            }
+        }
+
+        Rectangle { width: parent.width; height: 1; color: "#131c2e" }
+
+        // Per-stem confidence
+        Rectangle {
+            width: parent.width
+            height: stemConfCol.implicitHeight + 20
+            color: "transparent"
+            visible: job !== null
+            Column {
+                id: stemConfCol
+                anchors { left: parent.left; right: parent.right; top: parent.top; margins: 16 }
+                spacing: 8
+                Text { text: "CONFIDENCE"; color: "#475569"; font.pixelSize: 10; font.letterSpacing: 1 }
+                Repeater {
+                    model: job ? job.stems : []
+                    Column {
+                        width: parent.width; spacing: 3
+                        Row {
+                            width: parent.width
+                            Text { text: modelData.name; color: "#94a3b8"; font.pixelSize: 11; width: parent.width * 0.5 }
+                            Text {
+                                text: modelData.confidence.toFixed(1) + "%"
+                                color: modelData.confidence>=90?"#34d399":modelData.confidence>=78?"#fbbf24":"#f87171"
+                                font.pixelSize: 11; width: parent.width*0.5; horizontalAlignment: Text.AlignRight
+                            }
+                        }
+                        Rectangle {
+                            width: parent.width; height: 3; radius: 2; color: "#1e2535"
+                            Rectangle {
+                                width: parent.width * modelData.confidence / 100
+                                height: parent.height; radius: 2
+                                color: modelData.confidence>=90?"#34d399":modelData.confidence>=78?"#fbbf24":"#f87171"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Rectangle { width: parent.width; height: 1; color: "#131c2e" }
+
+        // Export
+        Rectangle {
+            width: parent.width
+            height: exportCol.implicitHeight + 20
+            color: "transparent"
+            Column {
+                id: exportCol
+                anchors { left: parent.left; right: parent.right; top: parent.top; margins: 16 }
+                spacing: 10
+
+                Text { text: "EXPORT"; color: "#475569"; font.pixelSize: 10; font.letterSpacing: 1 }
+
+                _ExportBtn { label: "MIDI stems (.mid)"; icon: "♩"; enabled: job !== null && sessionId !== ""; onClicked: root.exportMidi() }
+                _ExportBtn { label: "Audio stems (.wav)"; icon: "🔊"; enabled: job !== null && sessionId !== ""; onClicked: root.exportWav() }
+            }
+        }
+    }
+
+    function _fmtTime(sec) {
+        const m = Math.floor(sec/60), s = Math.floor(sec%60)
+        return m + ":" + ("0"+s).slice(-2)
+    }
+
+    // ── Sub-components ────────────────────────────────────────────────────
+    component _MetricRow: Row {
+        property string label: ""
+        property string value: ""
+        width: parent.width; spacing: 0
+        Text { text: label; color: "#475569"; font.pixelSize: 11; width: parent.width * 0.45 }
+        Text { text: value; color: "#94a3b8"; font.pixelSize: 11; width: parent.width * 0.55; horizontalAlignment: Text.AlignRight }
+    }
+
+    component _ExportBtn: Rectangle {
+        property string label: ""
+        property string icon:  ""
+        property bool   enabled: true
+        signal clicked()
+        width: parent.width; height: 34; radius: 6
+        color: btnMouse.containsMouse ? "#1e2d4a" : "#131c2e"
+        border.color: "#2d3a52"
+        opacity: enabled ? 1.0 : 0.4
+        MouseArea { id: btnMouse; anchors.fill: parent; hoverEnabled: true; onClicked: if (parent.enabled) parent.clicked() }
+        Row {
+            anchors.centerIn: parent; spacing: 8
+            Text { text: icon;        color: "#60a5fa"; font.pixelSize: 13 }
+            Text { text: label;       color: "#cbd5e1"; font.pixelSize: 12 }
+        }
+    }
+}
diff --git a/frontend/qml/components/OmniBar.qml b/frontend/qml/components/OmniBar.qml
new file mode 100644
index 0000000..6bb8131
--- /dev/null
+++ b/frontend/qml/components/OmniBar.qml
@@ -0,0 +1,43 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Dialogs 1.3
+
+Item {
+    id: root
+    signal submitUrl(string url)
+    signal openFile(string path)
+
+    Rectangle {
+        anchors.fill: parent
+        color: "#161b27"
+
+        Row {
+            anchors { verticalCenter: parent.verticalCenter; left: parent.left; right: parent.right; leftMargin: 12; rightMargin: 12 }
+            spacing: 8
+
+            TextField {
+                id: urlInput
+                width: parent.width - openBtn.width - 20
+                height: 32
+                placeholderText: "YouTube URL or search…"
+                color: "#e2e8f0"
+                background: Rectangle { color: "#1e2535"; radius: 6 }
+                Keys.onReturnPressed: root.submitUrl(urlInput.text.trim())
+            }
+
+            Button {
+                id: openBtn
+                text: "Open file"
+                height: 32
+                onClicked: fileDialog.open()
+            }
+        }
+    }
+
+    FileDialog {
+        id: fileDialog
+        title: "Open audio file"
+        nameFilters: ["Audio files (*.mp3 *.wav *.flac *.aac *.ogg *.m4a *.opus *.webm *.mp4)", "All files (*)"]
+        onAccepted: root.openFile(fileDialog.fileUrl.toString().replace("file:///", ""))
+    }
+}
diff --git a/frontend/qml/components/Sidebar.qml b/frontend/qml/components/Sidebar.qml
new file mode 100644
index 0000000..d3a1572
--- /dev/null
+++ b/frontend/qml/components/Sidebar.qml
@@ -0,0 +1,136 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Rectangle {
+    id: root
+    property var job: null
+    signal loadSession(string sid)
+    color: "#090d18"
+
+    Column {
+        anchors { top: parent.top; left: parent.left; right: parent.right; topMargin: 0 }
+        spacing: 0
+
+        // Section: current stems
+        Rectangle {
+            width: parent.width; height: 36
+            color: "#0d1220"
+            Text {
+                anchors { verticalCenter: parent.verticalCenter; left: parent.left; leftMargin: 16 }
+                text: "STEMS"; color: "#334155"; font.pixelSize: 10; font.letterSpacing: 1.5
+            }
+            Text {
+                anchors { verticalCenter: parent.verticalCenter; right: parent.right; rightMargin: 16 }
+                text: job ? job.stems.length : "0"; color: "#475569"; font.pixelSize: 11
+            }
+        }
+
+        Repeater {
+            model: job ? job.stems : []
+
+            Rectangle {
+                width: root.width; height: 52
+                color: stemMouse.containsMouse ? "#111a2e" : "transparent"
+
+                MouseArea { id: stemMouse; anchors.fill: parent; hoverEnabled: true }
+
+                Row {
+                    anchors { verticalCenter: parent.verticalCenter; left: parent.left; leftMargin: 12 }
+                    spacing: 10
+
+                    // Color swatch
+                    Rectangle {
+                        width: 3; height: 36; radius: 2
+                        color: _stemColor(modelData.color)
+                        anchors.verticalCenter: parent.verticalCenter
+                    }
+
+                    // Icon placeholder
+                    Rectangle {
+                        width: 32; height: 32; radius: 6
+                        color: Qt.rgba(Qt.lighter(_stemColor(modelData.color), 1.2).r,
+                                       Qt.lighter(_stemColor(modelData.color), 1.2).g,
+                                       Qt.lighter(_stemColor(modelData.color), 1.2).b, 0.12)
+                        anchors.verticalCenter: parent.verticalCenter
+                        Text {
+                            anchors.centerIn: parent
+                            text: _stemIcon(modelData.id)
+                            font.pixelSize: 14
+                        }
+                    }
+
+                    Column {
+                        spacing: 3; anchors.verticalCenter: parent.verticalCenter
+                        Text { text: modelData.name;       color: "#cbd5e1"; font.pixelSize: 12; font.weight: Font.Medium }
+                        Text { text: modelData.instrument; color: "#475569"; font.pixelSize: 10 }
+                        Text {
+                            text: modelData.midi + " notes · " + Math.round(modelData.confidence) + "%"
+                            color: modelData.confidence >= 90 ? "#34d399" : modelData.confidence >= 78 ? "#fbbf24" : "#f87171"
+                            font.pixelSize: 10
+                        }
+                    }
+                }
+            }
+        }
+
+        // Divider
+        Rectangle { width: parent.width; height: 1; color: "#131c2e"; visible: job !== null }
+
+        // Section: history (fetched from backend)
+        Rectangle {
+            width: parent.width; height: 36
+            color: "#0d1220"
+            Text {
+                anchors { verticalCenter: parent.verticalCenter; left: parent.left; leftMargin: 16 }
+                text: "RECENT"; color: "#334155"; font.pixelSize: 10; font.letterSpacing: 1.5
+            }
+        }
+
+        ListView {
+            width: parent.width
+            height: Math.min(contentHeight, 200)
+            clip: true
+            model: histModel
+            delegate: Rectangle {
+                width: root.width; height: 46
+                color: hm.containsMouse ? "#111a2e" : "transparent"
+                MouseArea { id: hm; anchors.fill: parent; hoverEnabled: true; onClicked: root.loadSession(model.id) }
+                Column {
+                    anchors { left: parent.left; leftMargin: 16; verticalCenter: parent.verticalCenter }
+                    spacing: 3
+                    Text { text: model.title||"Untitled"; color: "#94a3b8"; font.pixelSize: 12; elide: Text.ElideRight; width: root.width-32 }
+                    Text { text: model.artist + " · " + model.stem_count + " stems"; color: "#475569"; font.pixelSize: 10 }
+                }
+            }
+        }
+    }
+
+    // Fetch history on load
+    ListModel { id: histModel }
+
+    Component.onCompleted: _fetchHistory()
+
+    function _fetchHistory() {
+        const xhr = new XMLHttpRequest()
+        xhr.open("GET", "http://127.0.0.1:7471/api/history?limit=20")
+        xhr.onreadystatechange = function() {
+            if (xhr.readyState === 4 && xhr.status === 200) {
+                const items = JSON.parse(xhr.responseText)
+                histModel.clear()
+                for (let i = 0; i < items.length; i++) histModel.append(items[i])
+            }
+        }
+        xhr.send()
+    }
+
+    function _stemColor(cssVar) {
+        const map = { "--s-drums":"#f97316","--s-bass":"#a855f7","--s-guitar":"#22c55e",
+                      "--s-keys":"#3b82f6","--s-vocal":"#ec4899","--s-synth":"#06b6d4",
+                      "--s-strings":"#84cc16","--s-brass":"#eab308","--s-wood":"#14b8a6","--s-perc":"#f59e0b" }
+        return map[cssVar] || "#60a5fa"
+    }
+    function _stemIcon(id) {
+        const map = { drums:"🥁", bass:"🎸", guitar:"🎸", piano:"🎹", vocals:"🎤", other:"🎵" }
+        return map[id] || "🎵"
+    }
+}
diff --git a/frontend/qml/components/StaffCanvas.qml b/frontend/qml/components/StaffCanvas.qml
new file mode 100644
index 0000000..534a4b8
--- /dev/null
+++ b/frontend/qml/components/StaffCanvas.qml
@@ -0,0 +1,281 @@
+/**
+ * StaffCanvas — QtQuick Canvas port of notation.js
+ * Renders a 5-line staff with real MIDI notes or seeded fake notes.
+ *
+ * Required properties:
+ *   stemData  : object  { id, name, clef, color, midiNotes[], density, seed }
+ *   tempo     : int
+ *   timeSig   : int[2]
+ *   bars      : int
+ */
+import QtQuick 2.15
+
+Canvas {
+    id: root
+
+    required property var    stemData
+    required property int    tempo
+    required property var    timeSig
+    required property int    bars
+
+    property real stemColor: "#60a5fa"
+
+    readonly property int SP         : 9          // staff space px
+    readonly property int STAFF_TOP  : 28         // y of top line
+    readonly property int FIRST_PAD  : 72         // clef + keysig + timesig width
+    readonly property int NOTE_PAD_L : 14
+    readonly property int NOTE_PAD_R : 12
+    readonly property int BAR_W      : timeSig[0] === 3 ? 128 : 162
+
+    implicitWidth:  FIRST_PAD + BAR_W * bars + 8
+    implicitHeight: 90
+
+    onStemDataChanged:  requestPaint()
+    onTempoChanged:     requestPaint()
+    onTimeSigChanged:   requestPaint()
+
+    onPaint: {
+        const ctx = getContext("2d")
+        ctx.clearRect(0, 0, width, height)
+        _drawStaff(ctx)
+        _drawClef(ctx)
+        _drawTimeSig(ctx)
+        _drawBarlines(ctx)
+
+        if (stemData && stemData.midiNotes && stemData.midiNotes.length > 0)
+            _drawRealNotes(ctx, stemData.midiNotes)
+        else
+            _drawFakeNotes(ctx)
+    }
+
+    // ── Staff lines ──────────────────────────────────────────────────────────
+    function _drawStaff(ctx) {
+        ctx.strokeStyle = "#2d3a52"
+        ctx.lineWidth = 1
+        for (let i = 0; i < 5; i++) {
+            const y = STAFF_TOP + i * SP
+            ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(width - 4, y); ctx.stroke()
+        }
+    }
+
+    // ── Barlines ─────────────────────────────────────────────────────────────
+    function _drawBarlines(ctx) {
+        for (let b = 0; b <= bars; b++) {
+            const x = FIRST_PAD + b * BAR_W
+            ctx.strokeStyle = b === bars ? "#4a5568" : "#2d3a52"
+            ctx.lineWidth   = b === bars ? 2 : 1
+            ctx.beginPath(); ctx.moveTo(x, STAFF_TOP); ctx.lineTo(x, STAFF_TOP + 4*SP); ctx.stroke()
+        }
+    }
+
+    // ── Clef (simplified rects — Bravura font not guaranteed on all OSes) ───
+    function _drawClef(ctx) {
+        const clef = stemData ? stemData.clef : "treble"
+        ctx.fillStyle = "#94a3b8"
+        ctx.font = "bold 11px monospace"
+        ctx.textAlign = "left"
+        if (clef === "bass") {
+            ctx.fillText("𝄢", 6, STAFF_TOP + SP * 1.5 + 4)
+        } else if (clef === "perc") {
+            ctx.fillRect(8,  STAFF_TOP + SP,     4, SP * 2)
+            ctx.fillRect(14, STAFF_TOP + SP,     4, SP * 2)
+        } else {
+            ctx.fillText("𝄞", 4, STAFF_TOP + SP * 3 + 4)
+        }
+    }
+
+    // ── Time signature digits ────────────────────────────────────────────────
+    function _drawTimeSig(ctx) {
+        ctx.fillStyle = "#94a3b8"
+        ctx.font = "bold 16px monospace"
+        ctx.textAlign = "center"
+        const tx = 58
+        ctx.fillText(timeSig[0], tx, STAFF_TOP + SP * 1.2)
+        ctx.fillText(timeSig[1], tx, STAFF_TOP + SP * 3.2)
+    }
+
+    // ── MIDI → diatonic position helpers ─────────────────────────────────────
+    readonly property var CHROM_DIA: [0,0,1,1,2,3,3,4,4,5,5,6]
+
+    function midiToDia(pitch) {
+        return Math.floor(pitch / 12) * 7 + CHROM_DIA[pitch % 12]
+    }
+
+    // clef bottom-line diatonic reference
+    function _clefBottom() {
+        const clef = stemData ? stemData.clef : "treble"
+        if (clef === "bass")  return 18   // G2
+        if (clef === "alto")  return 24   // C3
+        return 30                          // E4
+    }
+    function _clefMid() {
+        const clef = stemData ? stemData.clef : "treble"
+        if (clef === "bass")  return 22
+        if (clef === "alto")  return 28
+        return 34
+    }
+
+    function _yForDia(dia) {
+        const bottom = _clefBottom()
+        return STAFF_TOP + 4 * SP - (dia - bottom) * (SP / 2)
+    }
+
+    // ── Draw one notehead ────────────────────────────────────────────────────
+    function _drawNote(ctx, x, dia, filled, color) {
+        const y = _yForDia(dia)
+        const up = dia < _clefMid()
+        ctx.strokeStyle = color
+        ctx.fillStyle   = color
+        ctx.lineWidth   = 1.6
+
+        // notehead ellipse
+        ctx.save()
+        ctx.translate(x, y)
+        ctx.rotate(-0.35)
+        ctx.beginPath()
+        ctx.ellipse(0, 0, 5.2, 3.8, 0, 0, 2 * Math.PI)
+        if (filled) ctx.fill(); else ctx.stroke()
+        ctx.restore()
+
+        // stem
+        const stemLen = SP * 3.2
+        const sx = up ? x + 4.6 : x - 4.6
+        const sy1 = up ? y - 1 : y + 1
+        const sy2 = up ? y - stemLen : y + stemLen
+        ctx.lineWidth = 1.4
+        ctx.beginPath(); ctx.moveTo(sx, sy1); ctx.lineTo(sx, sy2); ctx.stroke()
+
+        // ledger lines
+        const top = _clefBottom() + 8
+        const bot = _clefBottom()
+        if (dia > top) {
+            for (let d = top + 2; d <= dia; d += 2) {
+                const ly = _yForDia(d)
+                ctx.lineWidth = 1.2
+                ctx.beginPath(); ctx.moveTo(x-8, ly); ctx.lineTo(x+8, ly); ctx.stroke()
+            }
+        } else if (dia < bot) {
+            for (let d = bot - 2; d >= dia; d -= 2) {
+                const ly = _yForDia(d)
+                ctx.lineWidth = 1.2
+                ctx.beginPath(); ctx.moveTo(x-8, ly); ctx.lineTo(x+8, ly); ctx.stroke()
+            }
+        }
+    }
+
+    // ── Draw rest symbol ─────────────────────────────────────────────────────
+    function _drawRest(ctx, x, v, color) {
+        ctx.fillStyle = color
+        ctx.strokeStyle = color
+        const my = STAFF_TOP + 2 * SP
+        if (v <= 1) {
+            ctx.fillRect(x - 5, my - SP - 3, 10, 4)
+        } else if (v === 2) {
+            ctx.fillRect(x - 5, my + 1, 10, 4)
+        } else if (v === 4) {
+            ctx.lineWidth = 1.5
+            ctx.beginPath(); ctx.moveTo(x, my - 8); ctx.lineTo(x+5, my+2); ctx.lineTo(x-2, my+7); ctx.stroke()
+        } else {
+            ctx.lineWidth = 1.3
+            ctx.beginPath(); ctx.arc(x, my, 3, 0, Math.PI * 2); ctx.stroke()
+        }
+    }
+
+    // ── Real MIDI rendering ──────────────────────────────────────────────────
+    function _drawRealNotes(ctx, midiNotes) {
+        const color = stemColor
+        const bps   = tempo / 60
+        const beats = timeSig[0]
+
+        // Quantize to 1/16 grid
+        function qz(b) { return Math.round(b * 4) / 4 }
+
+        const events = []
+        for (let i = 0; i < midiNotes.length; i++) {
+            const n = midiNotes[i]
+            if (n.drum) continue
+            const bs = qz(n.start * bps)
+            if (bs >= bars * beats) continue
+            events.push({ bs, dia: midiToDia(n.pitch) })
+        }
+
+        // Sort, deduplicate per slot (highest pitch wins)
+        const slotMap = {}
+        for (let i = 0; i < events.length; i++) {
+            const e = events[i]
+            const bar = Math.floor(e.bs / beats)
+            const slot = Math.round((e.bs - bar * beats) * 4)
+            const key = bar + ":" + slot
+            if (!slotMap[key] || e.dia > slotMap[key].dia)
+                slotMap[key] = { bar, slot, dia: e.dia }
+        }
+
+        ctx.lineWidth = 1.4
+        for (const key in slotMap) {
+            const e = slotMap[key]
+            const usable = BAR_W - NOTE_PAD_L - NOTE_PAD_R
+            const mx = FIRST_PAD + e.bar * BAR_W + NOTE_PAD_L
+            const x = mx + (e.slot / (beats * 4)) * usable
+            _drawNote(ctx, x, e.dia, true, color)
+        }
+    }
+
+    // ── Seeded fake notes (demo projects without MIDI) ───────────────────────
+    function _rng(seed) {
+        let s = (seed * 2654435761) % 2147483647
+        return function() { s = (s * 16807) % 2147483647; return s / 2147483647 }
+    }
+
+    function _drawFakeNotes(ctx) {
+        if (!stemData) return
+        const color = stemColor
+        const beats = timeSig[0]
+        const rnd   = _rng((stemData.seed || 1) + 0)
+        const clef  = stemData.clef || "treble"
+        if (clef === "perc") { _drawFakeDrums(ctx, beats, rnd, color); return }
+
+        const lo = _clefBottom() + 2
+        const hi = _clefBottom() + 12
+        let cur  = Math.round((lo + hi) / 2)
+
+        for (let m = 0; m < bars; m++) {
+            const usable = BAR_W - NOTE_PAD_L - NOTE_PAD_R
+            const mx     = FIRST_PAD + m * BAR_W + NOTE_PAD_L
+            const density = stemData.density || 2
+            const noteCount = density + Math.floor(rnd() * 2)
+            for (let n = 0; n < noteCount; n++) {
+                const x = mx + (n / noteCount) * usable + 8
+                const step = rnd() < 0.6 ? (rnd()<0.5?1:-1) : (rnd()<0.5?2:-2)
+                cur = Math.max(lo, Math.min(hi, cur + step))
+                _drawNote(ctx, x, cur, true, color)
+            }
+        }
+    }
+
+    function _drawFakeDrums(ctx, beats, rnd, color) {
+        const yHat   = _yForDia(_clefBottom() + 10)
+        const ySnare = _yForDia(_clefBottom() + 4)
+        const yKick  = _yForDia(_clefBottom())
+        for (let m = 0; m < bars; m++) {
+            const usable = BAR_W - NOTE_PAD_L - NOTE_PAD_R
+            const mx     = FIRST_PAD + m * BAR_W + NOTE_PAD_L
+            for (let b = 0; b < beats * 2; b++) {
+                const x = mx + (b / (beats * 2)) * usable + 8
+                // hihat X
+                ctx.strokeStyle = color; ctx.lineWidth = 1.6
+                ctx.beginPath(); ctx.moveTo(x-3,yHat-3); ctx.lineTo(x+3,yHat+3); ctx.stroke()
+                ctx.beginPath(); ctx.moveTo(x-3,yHat+3); ctx.lineTo(x+3,yHat-3); ctx.stroke()
+                // snare on backbeats
+                if (beats>=4 && (b===2||b===6)) {
+                    ctx.fillStyle=color; ctx.beginPath()
+                    ctx.ellipse(x,ySnare,4.8,3.5,-0.4,0,2*Math.PI); ctx.fill()
+                }
+                // kick
+                if (b===0||(rnd()<0.15&&b%2===0)) {
+                    ctx.fillStyle=color; ctx.beginPath()
+                    ctx.ellipse(x,yKick,4.8,3.5,-0.4,0,2*Math.PI); ctx.fill()
+                }
+            }
+        }
+    }
+}
diff --git a/frontend/qml/dialogs/.gitkeep b/frontend/qml/dialogs/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/frontend/qml/views/.gitkeep b/frontend/qml/views/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/frontend/qml/views/EmptyView.qml b/frontend/qml/views/EmptyView.qml
new file mode 100644
index 0000000..1ce00a3
--- /dev/null
+++ b/frontend/qml/views/EmptyView.qml
@@ -0,0 +1,24 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Item {
+    Column {
+        anchors.centerIn: parent
+        spacing: 16
+
+        Label {
+            text: "Aegis Score Studio"
+            font.pixelSize: 28
+            font.weight: Font.Light
+            color: "#e2e8f0"
+            anchors.horizontalCenter: parent.horizontalCenter
+        }
+
+        Label {
+            text: "Paste a YouTube URL or drop an audio file to begin."
+            color: "#64748b"
+            font.pixelSize: 14
+            anchors.horizontalCenter: parent.horizontalCenter
+        }
+    }
+}
diff --git a/frontend/qml/views/ErrorView.qml b/frontend/qml/views/ErrorView.qml
new file mode 100644
index 0000000..bf2dcc4
--- /dev/null
+++ b/frontend/qml/views/ErrorView.qml
@@ -0,0 +1,13 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Item {
+    property string message: ""
+    Column {
+        anchors.centerIn: parent
+        spacing: 16
+        Label { text: "Analysis failed"; color: "#f87171"; font.pixelSize: 18; anchors.horizontalCenter: parent.horizontalCenter }
+        Label { text: message; color: "#94a3b8"; font.pixelSize: 13; anchors.horizontalCenter: parent.horizontalCenter; wrapMode: Text.WordWrap; width: 400 }
+        Button { text: "Retry"; anchors.horizontalCenter: parent.horizontalCenter }
+    }
+}
diff --git a/frontend/qml/views/MainWindow.qml b/frontend/qml/views/MainWindow.qml
new file mode 100644
index 0000000..4e81ab5
--- /dev/null
+++ b/frontend/qml/views/MainWindow.qml
@@ -0,0 +1,175 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Window 2.15
+import "../components"
+
+ApplicationWindow {
+    id: root
+    visible: true
+    width: 1440; height: 900
+    minimumWidth: 1100; minimumHeight: 700
+    title: "Aegis Score Studio"
+    color: "#0b0e17"
+
+    // ── Global state ───────────────────────────────────────────────────────
+    property string scene:     "empty"
+    property var    liveJob:   null
+    property string sessionId: ""
+    property real   progress:  0.0
+    property int    stage:    -1
+    property string errorMsg:  ""
+
+    // ── Bridge connections ─────────────────────────────────────────────────
+    Connections {
+        target: AppBridge
+
+        function onSessionStarted(sid) {
+            root.sessionId = sid
+            root.scene     = "processing"
+            root.progress  = 0.0
+            root.liveJob   = null
+        }
+
+        function onProgressChanged(prog, stg, status) {
+            root.progress = prog
+            root.stage    = stg
+        }
+
+        function onAnalysisReady(job) {
+            root.liveJob = job
+            root.scene   = "success"
+        }
+
+        function onErrorOccurred(msg) {
+            root.errorMsg = msg
+            root.scene    = "error"
+        }
+    }
+
+    // ── Flash toast ────────────────────────────────────────────────────────
+    property alias flashText: flashToast.message
+    function flash(msg) { flashToast.show(msg) }
+
+    FlashToast { id: flashToast; anchors { bottom: parent.bottom; horizontalCenter: parent.horizontalCenter; bottomMargin: 24 } }
+
+    // ── Layout ─────────────────────────────────────────────────────────────
+    // Omnibar fixed at top
+    OmniBar {
+        id: omni
+        anchors { top: parent.top; left: parent.left; right: parent.right }
+        height: 46
+        onSubmitUrl:  (url)  => AppBridge.analyzeUrl(url)
+        onOpenFile:   (path) => AppBridge.openLocalFile(path)
+    }
+
+    RowLayout {
+        anchors { top: omni.bottom; left: parent.left; right: parent.right; bottom: statusBar.top }
+        spacing: 0
+
+        // Left sidebar
+        Sidebar {
+            Layout.preferredWidth: 220
+            Layout.fillHeight: true
+            job: root.liveJob
+            onLoadSession: (sid) => { /* TODO: restore session */ }
+        }
+
+        // Divider
+        Rectangle { Layout.preferredWidth: 1; Layout.fillHeight: true; color: "#1a2035" }
+
+        // Center content
+        Item {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            // Scene switcher
+            Loader {
+                id: centerLoader
+                anchors.fill: parent
+
+                states: [
+                    State { name: "empty";      when: root.scene === "empty";      PropertyChanges { target: centerLoader; source: "../views/EmptyView.qml" } },
+                    State { name: "processing"; when: root.scene === "processing"; PropertyChanges { target: centerLoader; source: "../views/ProcessingView.qml" } },
+                    State { name: "success";    when: root.scene === "success";    PropertyChanges { target: centerLoader; source: "../views/ScoreView.qml" } },
+                    State { name: "error";      when: root.scene === "error";      PropertyChanges { target: centerLoader; source: "../views/ErrorView.qml" } }
+                ]
+
+                onLoaded: {
+                    if (root.scene === "processing") {
+                        item.progress = Qt.binding(() => root.progress)
+                        item.stage    = Qt.binding(() => root.stage)
+                    }
+                    if (root.scene === "success") {
+                        item.job       = Qt.binding(() => root.liveJob)
+                        item.sessionId = Qt.binding(() => root.sessionId)
+                    }
+                    if (root.scene === "error") {
+                        item.message = Qt.binding(() => root.errorMsg)
+                    }
+                }
+            }
+        }
+
+        // Divider
+        Rectangle { Layout.preferredWidth: 1; Layout.fillHeight: true; color: "#1a2035" }
+
+        // Right inspector
+        Inspector {
+            Layout.preferredWidth: 270
+            Layout.fillHeight: true
+            job:       root.liveJob
+            sessionId: root.sessionId
+            onExportMidi: _downloadStems("midi")
+            onExportWav:  _downloadStems("wav")
+        }
+    }
+
+    // Status bar
+    Rectangle {
+        id: statusBar
+        anchors { left: parent.left; right: parent.right; bottom: parent.bottom }
+        height: 24
+        color: "#070b13"
+        border { width: 0; color: "transparent" }
+
+        Row {
+            anchors { verticalCenter: parent.verticalCenter; left: parent.left; leftMargin: 12 }
+            spacing: 20
+            Text { text: _sceneLabel();              color: "#475569"; font.pixelSize: 11 }
+            Text { text: _gpuLabel();                color: "#334155"; font.pixelSize: 11 }
+            Text { text: _audioLabel();              color: "#334155"; font.pixelSize: 11 }
+        }
+
+        Text {
+            anchors { verticalCenter: parent.verticalCenter; right: parent.right; rightMargin: 12 }
+            text: "Aegis Score Studio v0.1"
+            color: "#1e2d42"; font.pixelSize: 10
+        }
+    }
+
+    function _sceneLabel() {
+        const map = { empty:"Idle", processing:"Analyzing…", success:"Ready", error:"Error" }
+        return map[root.scene] || ""
+    }
+    function _gpuLabel() {
+        if (!root.liveJob) return ""
+        const g = root.liveJob.meta.gpu
+        return g.model + (g.vramTotal > 0 ? " · " + g.vram.toFixed(1) + "/" + g.vramTotal.toFixed(1) + " GB" : "")
+    }
+    function _audioLabel() {
+        if (!root.liveJob) return ""
+        const m = root.liveJob.meta
+        return (m.sampleRate/1000).toFixed(0) + " kHz · " + m.bitDepth + "-bit"
+    }
+
+    function _downloadStems(type) {
+        if (!root.liveJob) return
+        const sid = root.sessionId
+        root.liveJob.stems.forEach(function(s) {
+            const url = type === "midi" ? s.midi_url : s.audio_url
+            if (url) Qt.openUrlExternally("http://127.0.0.1:7471" + url)
+        })
+        root.flash("Downloading " + type.toUpperCase() + " files…")
+    }
+}
diff --git a/frontend/qml/views/ProcessingView.qml b/frontend/qml/views/ProcessingView.qml
new file mode 100644
index 0000000..2c517da
--- /dev/null
+++ b/frontend/qml/views/ProcessingView.qml
@@ -0,0 +1,68 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+
+Item {
+    property real progress: 0.0
+
+    readonly property var stages: [
+        "Fetch & decode audio",
+        "Source separation (Demucs)",
+        "Instrument identification",
+        "MIDI transcription",
+        "Notation engraving",
+    ]
+
+    Column {
+        anchors.centerIn: parent
+        spacing: 24
+        width: 420
+
+        Label {
+            text: "Analyzing…"
+            font.pixelSize: 22
+            font.weight: Font.Medium
+            color: "#e2e8f0"
+            anchors.horizontalCenter: parent.horizontalCenter
+        }
+
+        // Progress bar
+        Rectangle {
+            width: parent.width
+            height: 6
+            radius: 3
+            color: "#1e2535"
+            Rectangle {
+                width: parent.width * progress
+                height: parent.height
+                radius: 3
+                color: "#60a5fa"
+                Behavior on width { SmoothedAnimation { duration: 300 } }
+            }
+        }
+
+        Label {
+            text: Math.round(progress * 100) + "%"
+            color: "#94a3b8"
+            anchors.horizontalCenter: parent.horizontalCenter
+        }
+
+        // Stage list
+        Repeater {
+            model: stages
+            Row {
+                spacing: 10
+                Rectangle {
+                    width: 8; height: 8; radius: 4
+                    color: index < Math.round(progress * 5) ? "#34d399" : "#334155"
+                    anchors.verticalCenter: parent.verticalCenter
+                }
+                Label {
+                    text: modelData
+                    color: index < Math.round(progress * 5) ? "#e2e8f0" : "#64748b"
+                    font.pixelSize: 13
+                }
+            }
+        }
+    }
+}
diff --git a/frontend/qml/views/ScoreView.qml b/frontend/qml/views/ScoreView.qml
new file mode 100644
index 0000000..fb483d8
--- /dev/null
+++ b/frontend/qml/views/ScoreView.qml
@@ -0,0 +1,191 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+import "../components"
+
+Item {
+    id: root
+    property var    job: null
+    property string sessionId: ""
+
+    readonly property var stems:  job ? (job.stems || []) : []
+    readonly property int tempo:  job ? (job.meta.tempo || 120) : 120
+    readonly property var timeSig: job ? (job.meta.timeSig || [4,4]) : [4,4]
+    readonly property int bars:   8
+
+    // Load MIDI notes from backend for each stem when job arrives
+    onJobChanged: {
+        if (!job || !sessionId) return
+        for (let i = 0; i < stems.length; i++) {
+            const s = stems[i]
+            if (s.midi_url && s.clef !== "perc") {
+                const xhr = new XMLHttpRequest()
+                xhr.open("GET", "http://127.0.0.1:7471/api/midi/" + sessionId + "/" + s.id)
+                xhr.onreadystatechange = (function(stemObj) {
+                    return function() {
+                        if (xhr.readyState === 4 && xhr.status === 200) {
+                            const d = JSON.parse(xhr.responseText)
+                            stemObj.midiNotes = d.notes || []
+                            staffRepeater.itemAt(stems.indexOf(stemObj))?.reload()
+                        }
+                    }
+                })(s)
+                xhr.send()
+            }
+        }
+    }
+
+    ColumnLayout {
+        anchors.fill: parent
+        spacing: 0
+
+        // ── Transport bar ──────────────────────────────────────────────────
+        Rectangle {
+            Layout.fillWidth: true
+            height: 44
+            color: "#0d1220"
+
+            Row {
+                anchors { verticalCenter: parent.verticalCenter; left: parent.left; leftMargin: 16 }
+                spacing: 12
+
+                // Play/pause
+                Rectangle {
+                    width: 32; height: 32; radius: 6
+                    color: playBtn.containsMouse ? "#1e2d4a" : "#141c2e"
+                    border.color: "#2d3a52"
+                    MouseArea { id: playBtn; anchors.fill: parent; hoverEnabled: true }
+                    Text { anchors.centerIn: parent; text: "▶"; color: "#60a5fa"; font.pixelSize: 14 }
+                }
+
+                // Timecode
+                Rectangle {
+                    height: 32; width: 120; radius: 6
+                    color: "#0a0f1a"
+                    border.color: "#1e2535"
+                    Text { anchors.centerIn: parent; text: "001 : 1 : 00"; color: "#60a5fa"; font.family: "monospace"; font.pixelSize: 13 }
+                }
+
+                // Tempo
+                Text { text: tempo + " BPM"; color: "#94a3b8"; font.pixelSize: 13; anchors.verticalCenter: parent.verticalCenter }
+                Text { text: timeSig[0]+"/"+timeSig[1]; color: "#64748b"; font.pixelSize: 13; anchors.verticalCenter: parent.verticalCenter }
+                Text { text: job ? job.meta.key : ""; color: "#64748b"; font.pixelSize: 13; anchors.verticalCenter: parent.verticalCenter }
+            }
+
+            // Right: stem count
+            Text {
+                anchors { verticalCenter: parent.verticalCenter; right: parent.right; rightMargin: 16 }
+                text: stems.length + " stems · " + (stems.reduce((a,s)=>a+s.midi,0)).toLocaleString() + " MIDI events"
+                color: "#475569"; font.pixelSize: 12
+            }
+        }
+
+        Rectangle { Layout.fillWidth: true; height: 1; color: "#1e2535" }
+
+        // ── Score body ─────────────────────────────────────────────────────
+        ScrollView {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            clip: true
+            ScrollBar.horizontal.policy: ScrollBar.AsNeeded
+            ScrollBar.vertical.policy: ScrollBar.AsNeeded
+
+            Column {
+                width: implicitWidth
+                spacing: 0
+
+                // Song title header
+                Rectangle {
+                    width: Math.max(parent.width, 600)
+                    height: 56
+                    color: "#0b0f1a"
+                    Column {
+                        anchors { left: parent.left; leftMargin: 72; verticalCenter: parent.verticalCenter }
+                        spacing: 3
+                        Text { text: job ? job.meta.title  : ""; color: "#e2e8f0"; font.pixelSize: 18; font.weight: Font.Light }
+                        Text { text: job ? (job.meta.artist + " · " + job.meta.key + " · ♩ = " + tempo) : ""; color: "#64748b"; font.pixelSize: 12 }
+                    }
+                }
+
+                // Staff rows
+                Repeater {
+                    id: staffRepeater
+                    model: stems
+
+                    Rectangle {
+                        id: staffRow
+                        width: Math.max(staffCanvas.implicitWidth + 68 + 8, 600)
+                        height: 90
+                        color: index % 2 === 0 ? "#0f1117" : "#0b0e17"
+
+                        // Left label
+                        Item {
+                            id: labelCol
+                            width: 68
+                            height: parent.height
+
+                            Column {
+                                anchors { right: parent.right; rightMargin: 8; verticalCenter: parent.verticalCenter }
+                                spacing: 3
+
+                                Text {
+                                    text: modelData.name
+                                    color: "#cbd5e1"; font.pixelSize: 11; font.weight: Font.Medium
+                                    horizontalAlignment: Text.AlignRight
+                                    width: 60; elide: Text.ElideRight
+                                }
+                                Text {
+                                    text: Math.round(modelData.confidence) + "%"
+                                    color: modelData.confidence >= 90 ? "#34d399" : modelData.confidence >= 78 ? "#fbbf24" : "#f87171"
+                                    font.pixelSize: 10
+                                    horizontalAlignment: Text.AlignRight
+                                    width: 60
+                                }
+                            }
+                        }
+
+                        // Staff canvas
+                        StaffCanvas {
+                            id: staffCanvas
+                            x: 68
+                            y: 0
+                            height: parent.height
+                            stemData:  modelData
+                            tempo:     root.tempo
+                            timeSig:   root.timeSig
+                            bars:      root.bars
+                            stemColor: _stemColor(modelData.color)
+
+                            function reload() { requestPaint() }
+                        }
+
+                        // Stem color bar
+                        Rectangle {
+                            x: 64; y: 16; width: 3; height: 58; radius: 2
+                            color: _stemColor(modelData.color)
+                        }
+                    }
+                }
+
+                // Bottom padding
+                Item { height: 40; width: parent.width }
+            }
+        }
+    }
+
+    function _stemColor(cssVar) {
+        const map = {
+            "--s-drums":  "#f97316",
+            "--s-bass":   "#a855f7",
+            "--s-guitar": "#22c55e",
+            "--s-keys":   "#3b82f6",
+            "--s-vocal":  "#ec4899",
+            "--s-synth":  "#06b6d4",
+            "--s-strings":"#84cc16",
+            "--s-brass":  "#eab308",
+            "--s-wood":   "#14b8a6",
+            "--s-perc":   "#f59e0b",
+        }
+        return map[cssVar] || "#60a5fa"
+    }
+}
diff --git a/index.html b/index.html
index f4fff85..28aae6a 100644
--- a/index.html
+++ b/index.html
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+<script>window.__API__ = 'http://127.0.0.1:7471';</script>
 <meta charset="UTF-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <title>Aegis Score Studio</title>
@@ -18,9 +19,134 @@
   .rk-lab{ position:absolute; top:5px; left:4px; font-family:var(--mono); font-size:9.5px; color:var(--t-2); }
   #grid-canvas{ position:absolute; inset:0; z-index:0; pointer-events:none; }
   .lanes-inner{ position:relative; z-index:1; }
+  /* focus track panel */
+  #ov-focus{ position:fixed;bottom:0;left:0;right:0;z-index:120;display:none;pointer-events:none; }
+  #ov-focus.show{ display:block;pointer-events:auto; }
+  .focus-panel{ background:var(--bg-1,#14141c);border-top:1px solid var(--acc-line,rgba(255,255,255,.12));padding:10px 16px 14px;box-shadow:0 -8px 32px rgba(0,0,0,.5); }
+  .focus-hdr{ display:flex;align-items:center;gap:8px;margin-bottom:8px; }
+  .focus-hdr .fdot{ width:10px;height:10px;border-radius:50%;flex-shrink:0; }
+  .focus-hdr .fname{ font-size:13px;font-weight:600;color:var(--t-0,#fff); }
+  .focus-hdr .finfo{ font-size:11px;color:var(--t-3,rgba(255,255,255,.35));margin-left:4px; }
+  .focus-hdr .fclose{ margin-left:auto;background:none;border:none;color:var(--t-2,rgba(255,255,255,.4));cursor:pointer;font-size:15px;line-height:1;padding:4px 6px;border-radius:4px; }
+  .focus-hdr .fclose:hover{ background:var(--bg-3,rgba(255,255,255,.06));color:var(--t-0,#fff); }
+  .focus-wave-wrap{ position:relative;height:80px;border-radius:5px;overflow:hidden;background:var(--bg-2,#1a1a22);cursor:crosshair; }
+  #focus-wave-cv{ display:block; }
+  .focus-ph{ position:absolute;top:0;bottom:0;width:2px;background:rgba(255,255,255,.9);left:0%;pointer-events:none;box-shadow:0 0 6px rgba(255,255,255,.45); }
+  /* processing waveform animation */
+  .proc-anim-wrap{ display:flex;justify-content:center;align-items:flex-end;padding:18px 0 14px; }
+  .proc-wave-anim{ width:110px;height:44px; }
+  @keyframes pb-dance{ 0%,100%{ transform:scaleY(.12); } 50%{ transform:scaleY(1); } }
+  .pb{ fill:var(--acc,oklch(.65 .18 260));transform-origin:50% 100%;animation:pb-dance 1.05s ease-in-out infinite; }
+  .pb:nth-child(1){ animation-delay:0s;   animation-duration:1.00s; }
+  .pb:nth-child(2){ animation-delay:.13s; animation-duration:1.18s; }
+  .pb:nth-child(3){ animation-delay:.05s; animation-duration:0.92s; }
+  .pb:nth-child(4){ animation-delay:.22s; animation-duration:1.26s; }
+  .pb:nth-child(5){ animation-delay:.08s; animation-duration:1.04s; }
+  .pb:nth-child(6){ animation-delay:.17s; animation-duration:1.15s; }
+  .pb:nth-child(7){ animation-delay:.03s; animation-duration:0.96s; }
+  .pb:nth-child(8){ animation-delay:.20s; animation-duration:1.10s; }
+  .pb:nth-child(9){ animation-delay:.11s; animation-duration:1.02s; }
+  .nav-empty-msg{ padding:12px;font-size:12px;color:var(--t-3,rgba(255,255,255,.3));font-style:italic; }
+  .proj-title-row{ padding:8px 12px 4px;font-size:11px;font-weight:600;color:var(--t-2);letter-spacing:.04em;text-transform:uppercase; }
+  /* File dropdown */
+  .mb-item{ position:relative; display:inline-block; }
+  .mb-dd{ display:none;position:absolute;top:100%;left:0;z-index:200;min-width:210px;
+    background:var(--bg-2,#1a1a26);border:1px solid var(--line,rgba(255,255,255,.1));
+    border-radius:6px;box-shadow:0 8px 24px rgba(0,0,0,.5);padding:6px 0; }
+  .mb-dd.open{ display:block; }
+  .dd-sect{ padding:6px 12px 4px;font-size:10px;font-weight:600;text-transform:uppercase;
+    letter-spacing:.06em;color:var(--t-3,rgba(255,255,255,.3)); }
+  .dd-row{ display:flex;align-items:center;gap:8px;padding:4px 12px; }
+  .dd-lbl{ font-size:11px;color:var(--t-2,rgba(255,255,255,.55));white-space:nowrap; }
+  .dd-row select{ flex:1;background:var(--bg-3,rgba(255,255,255,.06));border:1px solid var(--line);
+    color:var(--t-0,#fff);border-radius:4px;padding:3px 6px;font-size:11px; }
+  .dd-sep{ height:1px;background:var(--line,rgba(255,255,255,.1));margin:4px 0; }
+  .dd-item{ display:block;width:100%;text-align:left;padding:6px 14px;background:none;border:none;
+    color:var(--t-1,rgba(255,255,255,.8));font-size:12px;cursor:pointer;border-radius:0; }
+  .dd-item:hover{ background:var(--bg-3,rgba(255,255,255,.06));color:var(--t-0,#fff); }
+  /* Score bar navigation */
+  .score-nav{ display:flex;align-items:center;justify-content:center;gap:12px;
+    padding:10px 0 4px;border-top:1px solid var(--line,rgba(255,255,255,.08));margin-top:12px; }
+  .score-nav button{ background:var(--bg-3,rgba(255,255,255,.06));border:1px solid var(--line);
+    color:var(--t-1);font-size:11px;padding:4px 12px;border-radius:4px;cursor:pointer; }
+  .score-nav button:hover{ background:var(--acc,oklch(.55 .16 260));color:#fff;border-color:transparent; }
+  .score-nav button:disabled{ opacity:.3;cursor:default; }
+  #score-nav-label{ font-size:11px;color:var(--t-2);font-family:var(--mono);min-width:80px;text-align:center; }
+
+  /* ── Godot-style Project Opener ─────────────────────── */
+  #proj-opener{ display:none;position:fixed;inset:0;z-index:600;
+    background:rgba(0,0,0,.72);backdrop-filter:blur(14px);-webkit-backdrop-filter:blur(14px);
+    align-items:center;justify-content:center; }
+  [data-scene="empty"] #proj-opener{ display:flex; }
+  .po-card{ display:flex;width:min(880px,96vw);height:min(530px,90vh);
+    background:var(--bg-1);border:1px solid var(--line-strong);border-radius:12px;
+    overflow:hidden;box-shadow:0 40px 100px rgba(0,0,0,.75); }
+  .po-sidebar{ width:220px;flex-shrink:0;background:var(--bg-0);
+    border-right:1px solid var(--line);padding:24px 0;display:flex;flex-direction:column;gap:0; }
+  .po-brand{ padding:0 20px 22px;border-bottom:1px solid var(--line);margin-bottom:10px; }
+  .po-brand .glyph{ width:28px;height:28px;border-radius:7px;background:var(--acc);margin-bottom:10px;
+    display:grid;place-items:center; }
+  .po-brand .glyph svg{ width:16px;height:16px; }
+  .po-appname{ font-size:15px;font-weight:800;color:var(--t-0);letter-spacing:-.02em; }
+  .po-tagline{ font-size:10.5px;color:var(--t-3);margin-top:3px;font-family:var(--mono); }
+  .po-nav{ padding:4px 8px;flex:1; }
+  .po-navitem{ display:flex;align-items:center;gap:9px;width:100%;padding:8px 12px;
+    border:none;background:none;color:var(--t-2);font-size:12.5px;border-radius:6px;
+    cursor:pointer;text-align:left;font-family:var(--ui); }
+  .po-navitem:hover{ background:var(--bg-2);color:var(--t-0); }
+  .po-navitem.active{ background:var(--acc-ghost);color:var(--acc-bright); }
+  .po-navitem svg{ flex-shrink:0;stroke:currentColor;fill:none;stroke-width:1.8;
+    stroke-linecap:round;stroke-linejoin:round; }
+  .po-foot{ padding:16px 18px 0;font-size:10px;color:var(--t-3);line-height:1.55; }
+  .po-content{ flex:1;overflow-y:auto;padding:34px 40px 28px; }
+  .po-panel{ display:none; }
+  .po-panel.active{ display:block; }
+  .po-h{ font-size:19px;font-weight:700;color:var(--t-0);margin-bottom:6px; }
+  .po-sub{ font-size:12px;color:var(--t-2);margin-bottom:26px;line-height:1.6; }
+  .po-lbl{ display:block;font-size:10.5px;font-weight:600;color:var(--t-2);
+    text-transform:uppercase;letter-spacing:.06em;margin-bottom:8px; }
+  .po-url-wrap{ display:flex;align-items:center;gap:10px;
+    background:var(--bg-2);border:1px solid var(--line-strong);
+    border-radius:7px;padding:10px 14px;transition:border-color .15s,box-shadow .15s; }
+  .po-url-wrap:focus-within{ border-color:var(--acc-line);box-shadow:0 0 0 2.5px var(--acc-glow); }
+  .po-url-inp{ flex:1;background:none;border:none;outline:none;
+    color:var(--t-0);font-size:13px;font-family:var(--mono); }
+  .po-url-inp::placeholder{ color:var(--t-3); }
+  .po-divider{ display:flex;align-items:center;gap:12px;
+    margin:20px 0;color:var(--t-3);font-size:10.5px; }
+  .po-divider::before,.po-divider::after{ content:'';flex:1;height:1px;background:var(--line); }
+  .po-drop{ border:1.5px dashed var(--line-strong);border-radius:8px;padding:22px;
+    text-align:center;cursor:pointer;transition:border-color .15s,background .15s; }
+  .po-drop:hover,.po-drop.drag-over{ border-color:var(--acc-line);background:var(--acc-ghost); }
+  .po-drop-ico{ opacity:.35;margin-bottom:10px; }
+  .po-drop-title{ font-size:13px;font-weight:600;color:var(--t-1);margin-bottom:4px; }
+  .po-drop-sub{ font-size:10.5px;color:var(--t-3);margin-bottom:14px;font-family:var(--mono); }
+  .po-browse-btn{ background:var(--bg-3);border:1px solid var(--line-strong);
+    color:var(--t-1);font-size:12px;padding:6px 18px;border-radius:5px;cursor:pointer;
+    font-family:var(--ui); }
+  .po-browse-btn:hover{ background:var(--bg-4);color:var(--t-0); }
+  .po-actions{ margin-top:24px;display:flex;justify-content:flex-end;gap:10px; }
+  .po-go{ background:var(--acc);color:#fff;border:none;
+    font-size:13.5px;font-weight:600;padding:10px 28px;
+    border-radius:7px;cursor:pointer;letter-spacing:.01em;font-family:var(--ui);
+    transition:background .12s; }
+  .po-go:hover{ background:var(--acc-bright); }
+  .po-no-recent{ color:var(--t-3);font-size:13px;padding:28px 0;text-align:center; }
+  .po-recent-item{ display:flex;align-items:center;gap:14px;padding:12px 14px;
+    border-radius:7px;cursor:pointer;border:1px solid transparent;position:relative; }
+  .po-recent-item:hover{ background:var(--bg-2);border-color:var(--line); }
+  .po-ri-thumb{ width:42px;height:42px;border-radius:5px;flex-shrink:0;
+    background:var(--bg-3);object-fit:cover; }
+  .po-ri-title{ font-size:13px;font-weight:600;color:var(--t-0);margin-bottom:2px; }
+  .po-ri-sub{ font-size:11px;color:var(--t-3);font-family:var(--mono); }
+  .po-ri-more{ display:none;position:absolute;right:10px;top:50%;transform:translateY(-50%);
+    background:var(--bg-3);border:1px solid var(--line-strong);border-radius:4px;
+    color:var(--t-1);font-size:16px;line-height:1;padding:1px 7px 3px;cursor:pointer; }
+  .po-recent-item:hover .po-ri-more{ display:block; }
+  .po-ri-more:hover{ background:var(--bg-4);color:var(--t-0); }
 </style>
 </head>
-<body data-scene="success" data-project="band">
+<body data-scene="empty">
 
 <div class="app">
 
@@ -31,16 +157,28 @@
       <div class="name">AEGIS<b>SCORE</b></div>
     </div>
     <nav class="menubar">
-      <button>File</button><button>Edit</button><button>Analyze</button><button>Score</button><button>View</button>
+      <div class="mb-item" id="mb-file">
+        <button id="btn-file-menu" onclick="toggleFileMenu(event)">File</button>
+        <div class="mb-dd" id="dd-file">
+          <div class="dd-sect">Export Score</div>
+          <div class="dd-row">
+            <label class="dd-lbl">Track</label>
+            <select id="exp-stem-sel"></select>
+          </div>
+          <div class="dd-sep"></div>
+          <button class="dd-item" onclick="exportScore('musicxml')">MusicXML (.musicxml)</button>
+          <button class="dd-item" onclick="exportScore('musescore')">MuseScore (.mscz)</button>
+          <button class="dd-item" onclick="exportScore('pdf')">PDF (print)</button>
+        </div>
+      </div>
+      <button data-menubar="analyze">Analyze</button><button data-menubar="score">Score</button><button data-menubar="view">View</button>
     </nav>
     <div class="omnibox" id="omnibox">
       <svg class="yt" width="16" height="16" viewBox="0 0 24 24" fill="currentColor"><path d="M23 12s0-3.4-.4-5a2.8 2.8 0 0 0-2-2C18.9 4.5 12 4.5 12 4.5s-6.9 0-8.6.5a2.8 2.8 0 0 0-2 2C1 8.6 1 12 1 12s0 3.4.4 5a2.8 2.8 0 0 0 2 2c1.7.5 8.6.5 8.6.5s6.9 0 8.6-.5a2.8 2.8 0 0 0 2-2c.4-1.6.4-5 .4-5Z"/><path d="M9.8 15.5V8.5L15.5 12l-5.7 3.5Z" fill="#0d0d10"/></svg>
-      <input id="omni-input" value="https://youtube.com/watch?v=k7Qm2x9LpZ4" spellcheck="false" />
+      <input id="omni-input" placeholder="Paste a YouTube URL…" spellcheck="false" />
       <span class="kbd">⌘L</span>
     </div>
     <div class="top-right">
-      <div class="meter gpu" title="GPU utilization"><span class="lbl">GPU</span><span class="bar"><i id="gpu-bar" style="width:14%"></i></span><span class="val" id="gpu-val">14%</span></div>
-      <div class="meter vram" title="VRAM"><span class="lbl">VRAM</span><span class="bar"><i id="vram-bar" style="width:26%"></i></span><span class="val" id="vram-val">6.2G</span></div>
       <button class="iconbtn" id="btn-cmdk" title="Command palette ⌘K"><svg viewBox="0 0 24 24" class="ico-stroke"><circle cx="11" cy="11" r="7"/><path d="M20 20l-3.5-3.5"/></svg></button>
       <button class="iconbtn" title="Notifications"><svg viewBox="0 0 24 24" class="ico-stroke"><path d="M18 8a6 6 0 0 0-12 0c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.7 21a2 2 0 0 1-3.4 0"/></svg></button>
       <div class="avatar">JD</div>
@@ -51,9 +189,9 @@
   <div class="sub">
     <div class="crumbs">
       <span class="dot" id="crumb-dot"></span>
-      <span>Workspace</span><span class="sep">/</span>
-      <span>Atlas of Sleep</span><span class="sep">/</span>
-      <b id="crumb-title">Midnight Cartography</b>
+      <span>Workspace</span>
+      <span class="sep" id="crumb-sep" style="display:none">/</span>
+      <b id="crumb-title"></b>
     </div>
     <span class="pill ok" id="scene-pill"><span class="pdot"></span><span id="scene-pill-t">Analysis complete</span></span>
     <div class="sub-meta" id="sub-meta"></div>
@@ -62,19 +200,9 @@
   <!-- ============ LEFT ============ -->
   <aside class="left">
     <div class="left-scroll">
-      <div class="section">
-        <div class="panel-head">Project Navigator <span class="count" id="nav-count"></span></div>
-        <div class="tree" id="nav-tree"></div>
-      </div>
-      <div class="section">
-        <div class="panel-head">Files
-          <span class="hbtn" title="New folder"><svg width="13" height="13" viewBox="0 0 24 24" class="ico-stroke"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2Z"/></svg></span>
-        </div>
-        <div class="tree" id="file-tree"></div>
-      </div>
       <div class="section flexgrow">
-        <div class="panel-head">Analysis History <span class="count" id="hist-count"></span></div>
-        <div class="tree" id="hist-list" style="padding:0"></div>
+        <div class="panel-head">Current Song <span class="count" id="nav-count"></span></div>
+        <div class="tree" id="nav-tree"></div>
       </div>
     </div>
   </aside>
@@ -103,6 +231,11 @@
       <div class="score-paper" id="score-paper">
         <div class="score-titleblock" id="score-title"></div>
         <div class="systems" id="score-systems"></div>
+        <div class="score-nav" id="score-nav">
+          <button id="score-prev" onclick="scoreNavStep(-1)">&#8592; Prev</button>
+          <span id="score-nav-label"></span>
+          <button id="score-next" onclick="scoreNavStep(1)">Next &#8594;</button>
+        </div>
       </div>
     </div>
 
@@ -118,11 +251,7 @@ <h2>Deconstruct any track</h2>
             <input placeholder="Paste a YouTube link, or drop an audio file…" spellcheck="false" id="empty-input" />
             <button class="go" id="empty-go">Analyze</button>
           </div>
-          <div class="empty-recents">
-            <span class="er" data-load="band"><span class="erc" style="background:var(--s-synth)"></span>Midnight Cartography</span>
-            <span class="er" data-load="orchestra"><span class="erc" style="background:var(--s-strings)"></span>Aurora Borealis Suite</span>
-            <span class="er" data-load="piano"><span class="erc" style="background:var(--s-keys)"></span>Gymnopédie No. 1</span>
-          </div>
+          <div class="empty-recents"></div>
         </div>
       </div>
     </div>
@@ -131,12 +260,25 @@ <h2>Deconstruct any track</h2>
       <div class="proc">
         <div class="proc-head">
           <div class="proc-thumb" id="proc-thumb"></div>
-          <div><div class="proc-tt" id="proc-tt">Midnight Cartography</div><div class="proc-ts" id="proc-ts">Neon Tide · 3:38 · 48 kHz/24-bit</div></div>
+          <div><div class="proc-tt" id="proc-tt">Fetching…</div><div class="proc-ts" id="proc-ts"></div></div>
           <div class="proc-pct" id="proc-pct">0%</div>
         </div>
+        <div class="proc-anim-wrap">
+          <svg class="proc-wave-anim" viewBox="0 0 110 44" xmlns="http://www.w3.org/2000/svg">
+            <rect class="pb" x="0"  y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="12" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="24" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="36" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="48" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="60" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="72" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="84" y="4" width="8" height="40" rx="4"/>
+            <rect class="pb" x="96" y="4" width="8" height="40" rx="4"/>
+          </svg>
+        </div>
         <div class="proc-stages" id="proc-stages"></div>
         <div class="proc-bar"><i id="proc-bar-i" style="width:0%"></i></div>
-        <div class="proc-foot"><span id="proc-eta">Estimating…</span><span id="proc-gpu">GPU · RTX 4090</span></div>
+        <div class="proc-foot"><span id="proc-eta">Estimating…</span></div>
       </div>
     </div>
 
@@ -178,12 +320,13 @@ <h2>Deconstruct any track</h2>
         <button class="tbtn play" id="tp-play" title="Play/Pause (Space)"><svg id="play-ico" viewBox="0 0 24 24" fill="currentColor"><path d="M7 4l13 8-13 8z"/></svg></button>
         <button class="tbtn" id="tp-stop" title="Stop"><svg viewBox="0 0 24 24" fill="currentColor"><rect x="6" y="6" width="12" height="12" rx="1.5"/></svg></button>
         <button class="tbtn" id="tp-loop" title="Loop"><svg viewBox="0 0 24 24" class="ico-stroke"><path d="M17 2l4 4-4 4"/><path d="M3 11V9a4 4 0 0 1 4-4h14"/><path d="M7 22l-4-4 4-4"/><path d="M21 13v2a4 4 0 0 1-4 4H3"/></svg></button>
+        <button class="tbtn tp-mode-btn" id="tp-mode" title="Toggle WAV / MIDI synth playback">WAV</button>
       </div>
-      <div class="timecode"><span id="tc-bars">009</span><span class="sep2">:</span><span id="tc-beat">1</span><span class="sep2">:</span><span id="tc-tick">00</span><span class="ms" id="tc-time">0:16.2</span></div>
+      <div class="timecode"><span id="tc-bars">001</span><span class="sep2">:</span><span id="tc-beat">1</span><span class="sep2">:</span><span id="tc-tick">00</span><span class="ms" id="tc-time">0:00.0</span></div>
       <div class="tl-stats">
-        <div class="tl-stat"><span class="k">Tempo</span><span class="v" id="st-tempo">122 <small>BPM</small></span></div>
-        <div class="tl-stat"><span class="k">Sig</span><span class="v" id="st-sig">4/4</span></div>
-        <div class="tl-stat"><span class="k">Key</span><span class="v" id="st-key">F# min</span></div>
+        <div class="tl-stat"><span class="k">Tempo</span><span class="v" id="st-tempo">—</span></div>
+        <div class="tl-stat"><span class="k">Sig</span><span class="v" id="st-sig">—</span></div>
+        <div class="tl-stat"><span class="k">Key</span><span class="v" id="st-key">—</span></div>
       </div>
       <div class="tl-right">
         <button class="tl-toggle on" id="tg-wave"><svg width="13" height="13" viewBox="0 0 24 24" class="ico-stroke"><path d="M2 12h2l3-8 4 16 3-12 2 6h6"/></svg>Waveform</button>
@@ -224,27 +367,114 @@ <h2>Deconstruct any track</h2>
 
   <!-- ============ STATUS BAR ============ -->
   <footer class="status">
-    <div class="sb"><span class="sdot" style="background:var(--good)"></span><b id="sbar-model">HT-Demucs v4</b></div>
-    <div class="sb"><span id="sbar-stems">6 stems</span> · <span id="sbar-midi">912 MIDI events</span></div>
-    <div class="sb acc" id="sbar-sel">Lead Synth selected</div>
-    <div class="sb right">48 kHz · 24-bit</div>
+    <div class="sb"><span class="sdot" id="sbar-dot" style="background:var(--t-3)"></span><b id="sbar-model">—</b></div>
+    <div class="sb"><span id="sbar-stems">—</span></div>
+    <div class="sb acc" id="sbar-sel">—</div>
+    <div class="sb right" id="sbar-fmt"></div>
     <div class="sb"><span class="mono" id="sbar-zoom">100%</span></div>
-    <div class="sb"><span id="sbar-scene">Ready</span></div>
+    <div class="sb"><span id="sbar-scene">Idle</span></div>
   </footer>
 
 </div>
 
+<!-- ============ PROJECT OPENER (Godot-style) ============ -->
+<div id="proj-opener">
+  <div class="po-card">
+    <!-- Left sidebar -->
+    <div class="po-sidebar">
+      <div class="po-brand">
+        <div class="glyph">
+          <svg viewBox="0 0 24 24" fill="none" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/>
+          </svg>
+        </div>
+        <div class="po-appname">AEGIS<b>SCORE</b></div>
+        <div class="po-tagline">Studio · v1.0</div>
+      </div>
+      <nav class="po-nav">
+        <button class="po-navitem active" data-po="open">
+          <svg viewBox="0 0 24 24" width="15" height="15"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3"/></svg>
+          Open Source
+        </button>
+        <button class="po-navitem" data-po="recent">
+          <svg viewBox="0 0 24 24" width="15" height="15"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></svg>
+          Recent Sessions
+        </button>
+      </nav>
+      <div class="po-foot">Audio is processed locally.<br/>Nothing leaves your machine.</div>
+    </div>
+
+    <!-- Right content -->
+    <div class="po-content">
+
+      <!-- Open panel -->
+      <div class="po-panel active" id="po-panel-open">
+        <div class="po-h">Open Audio Source</div>
+        <div class="po-sub">Paste a YouTube link or drag in a local audio file to separate stems, transcribe MIDI, and engrave notation.</div>
+
+        <label class="po-lbl">YouTube / stream URL</label>
+        <div class="po-url-wrap">
+          <svg class="yt" width="16" height="16" viewBox="0 0 24 24" fill="var(--bad)"><path d="M23 12s0-3.4-.4-5a2.8 2.8 0 0 0-2-2C18.9 4.5 12 4.5 12 4.5s-6.9 0-8.6.5a2.8 2.8 0 0 0-2 2C1 8.6 1 12 1 12s0 3.4.4 5a2.8 2.8 0 0 0 2 2c1.7.5 8.6.5 8.6.5s6.9 0 8.6-.5a2.8 2.8 0 0 0 2-2c.4-1.6.4-5 .4-5Z"/><path d="M9.8 15.5V8.5L15.5 12l-5.7 3.5Z" fill="#0d0d10"/></svg>
+          <input class="po-url-inp" id="po-url" placeholder="https://www.youtube.com/watch?v=…" spellcheck="false" autocomplete="off" />
+        </div>
+
+        <div class="po-divider"><span>or</span></div>
+
+        <div class="po-drop" id="po-drop-zone">
+          <div class="po-drop-ico">
+            <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round" style="color:var(--t-2)">
+              <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="17 8 12 3 7 8"/><line x1="12" y1="3" x2="12" y2="15"/>
+            </svg>
+          </div>
+          <div class="po-drop-title">Drop an audio file here</div>
+          <div class="po-drop-sub">MP3 · WAV · FLAC · AAC · OGG · M4A · MP4 · WEBM</div>
+          <button class="po-browse-btn" onclick="document.getElementById('file-picker').click()">Browse Files…</button>
+        </div>
+
+        <div class="po-actions">
+          <button class="po-go" id="po-go-btn">Analyze &nbsp;→</button>
+        </div>
+      </div>
+
+      <!-- Recent panel -->
+      <div class="po-panel" id="po-panel-recent">
+        <div class="po-h">Recent Sessions</div>
+        <div class="po-sub">Sessions from this browser. Reopen to skip reprocessing if the server still has the data.</div>
+        <div id="po-recent-list"><div class="po-no-recent">No recent sessions yet.</div></div>
+      </div>
+
+    </div>
+  </div>
+</div>
+
 <!-- context menu / hint / palette / flash -->
 <div class="ctx" id="ctx"></div>
 <div class="hint" id="hint"></div>
 <div class="cmdk-scrim" id="cmdk"><div class="cmdk"><div class="cmdk-input"><svg viewBox="0 0 24 24" class="ico-stroke"><circle cx="11" cy="11" r="7"/><path d="M20 20l-3.5-3.5"/></svg><input id="cmdk-input" placeholder="Search actions, stems, projects…" /></div><div class="cmdk-list" id="cmdk-list"></div></div></div>
 <div class="flash" id="flash"><span class="fdot"></span><span id="flash-t"></span></div>
 
+<!-- focus track player -->
+<div id="ov-focus">
+  <div class="focus-panel">
+    <div class="focus-hdr">
+      <div class="fdot" id="focus-dot"></div>
+      <span class="fname" id="focus-name">Stem</span>
+      <span class="finfo" id="focus-info"></span>
+      <button class="fclose" id="focus-close">✕</button>
+    </div>
+    <div class="focus-wave-wrap" id="focus-wave-wrap">
+      <canvas id="focus-wave-cv"></canvas>
+      <div class="focus-ph" id="focus-ph"></div>
+    </div>
+  </div>
+</div>
+
 <input type="file" id="file-picker" accept="audio/*,video/*,.mp3,.wav,.flac,.aac,.ogg,.m4a,.mp4,.webm" style="display:none" />
 <script src="js/data.js"></script>
 <script src="js/notation.js"></script>
 <script src="js/waveform.js"></script>
 <script src="js/audio.js"></script>
+<script src="js/export.js"></script>
 <script src="js/controller.js"></script>
 </body>
 </html>
diff --git a/js/audio.js b/js/audio.js
index 4ed9ad7..7f11580 100644
--- a/js/audio.js
+++ b/js/audio.js
@@ -52,11 +52,17 @@ const AudioEngine = (() => {
   }
 
   // Start playback from offsetSecs into the audio
-  function start(offsetSecs = 0) {
+  async function start(offsetSecs = 0) {
     const ac = _ensureCtx();
+    // Set offset immediately so currentSecs() returns correct position during any async gap
+    _startOffset = offsetSecs;
+    // Await resume — critical: sources started in a suspended context may replay
+    // when context finally resumes, making stop() appear to have no effect
+    if (ac.state !== 'running') {
+      try { await ac.resume(); } catch (_) {}
+    }
     _stop_sources();
     _startCtxTime = ac.currentTime;
-    _startOffset  = offsetSecs;
     _playing = true;
 
     for (const [id, stem] of Object.entries(stems)) {
@@ -72,8 +78,11 @@ const AudioEngine = (() => {
   }
 
   function stop() {
+    if (_playing && ctx) _startOffset = _startOffset + (ctx.currentTime - _startCtxTime);
     _playing = false;
     _stop_sources();
+    // Suspend context — guarantees silence even if browser hasn't fully processed source.stop()
+    if (ctx && ctx.state === 'running') ctx.suspend().catch(() => {});
   }
 
   function _stop_sources() {
@@ -109,9 +118,176 @@ const AudioEngine = (() => {
     if (stems[id]) stems[id].gain.gain.setTargetAtTime(value, ctx?.currentTime || 0, 0.02);
   }
 
+  // Compute peak amplitudes at PEAK_RES points (cached on stem object)
+  const PEAK_RES = 512;
+  function getPeaks(id) {
+    const stem = stems[id];
+    if (!stem?.buffer) return null;
+    if (stem._peaks) return stem._peaks;
+    const buf = stem.buffer;
+    const total = buf.length;
+    const nCh = buf.numberOfChannels;
+    const blockSize = Math.ceil(total / PEAK_RES);
+    const peaks = new Float32Array(PEAK_RES);
+    for (let c = 0; c < nCh; c++) {
+      const data = buf.getChannelData(c);
+      for (let i = 0; i < PEAK_RES; i++) {
+        const start = i * blockSize;
+        const end = Math.min(start + blockSize, total);
+        let max = 0;
+        for (let j = start; j < end; j += 4) { // sample every 4th — 4× faster, negligible quality loss
+          const a = Math.abs(data[j]);
+          if (a > max) max = a;
+        }
+        if (max > peaks[i]) peaks[i] = max;
+      }
+    }
+    stem._peaks = peaks;
+    return peaks;
+  }
+
   function isLoaded() { return Object.values(stems).some(s => s.buffer); }
   function hasStem(id) { return !!(stems[id]?.buffer); }
 
   return { loadStem, loadFromSession, start, stop, currentSecs,
-           setMute, setSolo, setGain, isLoaded, hasStem };
+           setMute, setSolo, setGain, isLoaded, hasStem, getPeaks };
+})();
+
+/* ============================================================
+   MidiEngine — Web Audio API synthesiser for MIDI note playback
+   Schedules notes ~800 ms ahead in a rolling setTimeout loop.
+   ============================================================ */
+const MidiEngine = (() => {
+  let ctx = null;
+  let _notes = [];          // [{start,end,pitch,velocity,drum,stemId}] sorted by start
+  let _nodes = [];          // active AudioNodes for cleanup
+  let _startCtxTime = 0;
+  let _startOffset  = 0;
+  let _playing      = false;
+  let _nextIdx      = 0;
+  let _schedTimer   = null;
+  const AHEAD   = 0.8;   // schedule up to 800 ms ahead
+  const TICK_MS = 200;   // re-check every 200 ms
+  const _mutedStems  = new Set();
+  const _soloedStems = new Set();
+
+  function _ensureCtx(){
+    if(!ctx) ctx = new AudioContext();
+    if(ctx.state==='suspended') ctx.resume();
+    return ctx;
+  }
+
+  function load(stems){
+    _notes = [];
+    for(const s of stems){
+      if(!s.midiNotes?.length) continue;
+      for(const n of s.midiNotes) _notes.push({...n, stemId:s.id});
+    }
+    _notes.sort((a,b)=>a.start-b.start);
+  }
+
+  function _noteOn(ac, n, atTime){
+    const hasSolo = _soloedStems.size > 0;
+    if(_mutedStems.has(n.stemId)) return;
+    if(hasSolo && !_soloedStems.has(n.stemId)) return;
+
+    const dur = Math.max(0.04, n.end - n.start);
+    const vel = (n.velocity || 70) / 127;
+
+    if(n.drum){
+      const bufSize = Math.ceil(ac.sampleRate * Math.min(dur, 0.14));
+      const buf = ac.createBuffer(1, bufSize, ac.sampleRate);
+      const d = buf.getChannelData(0);
+      for(let i=0;i<bufSize;i++) d[i] = Math.random()*2-1;
+      const src = ac.createBufferSource(); src.buffer = buf;
+      const filt = ac.createBiquadFilter(); filt.type='bandpass';
+      filt.frequency.value = n.pitch<=36? 80 : n.pitch<=39? 220 : 7000;
+      filt.Q.value = 2;
+      const gain = ac.createGain();
+      gain.gain.setValueAtTime(0.55*vel, atTime);
+      gain.gain.exponentialRampToValueAtTime(0.0001, atTime+Math.min(dur,0.14));
+      src.connect(filt); filt.connect(gain); gain.connect(ac.destination);
+      src.start(atTime); src.stop(atTime+Math.min(dur,0.15));
+      _nodes.push(src, gain, filt);
+      return;
+    }
+
+    const freq = 440 * Math.pow(2, (n.pitch-69)/12);
+    const osc = ac.createOscillator();
+    osc.type = 'triangle';
+    osc.frequency.value = freq;
+    const gain = ac.createGain();
+    const v = vel * 0.38;
+    const att = 0.015, rel = Math.min(0.18, dur*0.3);
+    gain.gain.setValueAtTime(0, atTime);
+    gain.gain.linearRampToValueAtTime(v, atTime+att);
+    gain.gain.setValueAtTime(v*0.7, atTime+Math.max(att+0.001, dur-rel));
+    gain.gain.exponentialRampToValueAtTime(0.0001, atTime+dur);
+    osc.connect(gain); gain.connect(ac.destination);
+    osc.start(atTime); osc.stop(atTime+dur+0.02);
+    _nodes.push(osc, gain);
+  }
+
+  function _schedule(){
+    if(!_playing || !ctx) return;
+    const ac = ctx;
+    const nowAudio = _startOffset + (ac.currentTime - _startCtxTime);
+    const schedEnd = nowAudio + AHEAD;
+    while(_nextIdx < _notes.length && _notes[_nextIdx].start <= schedEnd){
+      const n = _notes[_nextIdx++];
+      if(n.start < nowAudio - 0.05) continue; // already past
+      const atTime = _startCtxTime + (n.start - _startOffset);
+      _noteOn(ac, n, Math.max(atTime, ac.currentTime + 0.001));
+    }
+    if(_nextIdx < _notes.length) _schedTimer = setTimeout(_schedule, TICK_MS);
+  }
+
+  async function start(offsetSecs=0){
+    const ac = _ensureCtx();
+    _startOffset = offsetSecs;
+    if(ac.state!=='running'){ try{ await ac.resume(); }catch(_){} }
+    _stop_nodes();
+    _startCtxTime = ac.currentTime;
+    _playing = true;
+    _nextIdx = 0;
+    // seek to first note at/after offset
+    while(_nextIdx < _notes.length && _notes[_nextIdx].start < offsetSecs - 0.05) _nextIdx++;
+    _schedule();
+  }
+
+  function stop(){
+    if(_playing && ctx) _startOffset += ctx.currentTime - _startCtxTime;
+    _playing = false;
+    clearTimeout(_schedTimer); _schedTimer = null;
+    _stop_nodes();
+    if(ctx?.state==='running') ctx.suspend().catch(()=>{});
+  }
+
+  function _stop_nodes(){
+    const t = ctx?.currentTime || 0;
+    for(const n of _nodes){
+      try{ if(n.stop) n.stop(t+0.01); }catch(_){}
+      try{ n.disconnect(); }catch(_){}
+    }
+    _nodes = [];
+  }
+
+  function currentSecs(){
+    if(!_playing || !ctx) return _startOffset;
+    return _startOffset + (ctx.currentTime - _startCtxTime);
+  }
+
+  function isLoaded(){ return _notes.length > 0; }
+
+  function setMute(id, muted){
+    if(muted) _mutedStems.add(id); else _mutedStems.delete(id);
+  }
+  function setSolo(soloSet){
+    _soloedStems.clear();
+    for(const id of soloSet) _soloedStems.add(id);
+  }
+  // Reload stems into engine (called after midiNotes fetch completes)
+  function reload(stems){ if(stems) load(stems); }
+
+  return { load, reload, start, stop, currentSecs, isLoaded, setMute, setSolo };
 })();
diff --git a/js/controller.js b/js/controller.js
index 937a81d..bb323b9 100644
--- a/js/controller.js
+++ b/js/controller.js
@@ -34,27 +34,46 @@ function iconFor(stem){
   return ICONS.synth;
 }
 function svgIco(path,cls){ return `<svg viewBox="0 0 24 24" class="${cls||'ico-stroke'}">${path}</svg>`; }
+const _api = p => (window.__API__ || '') + p;
 
 /* ---------------- STATE ---------------- */
 const STATE = {
-  pkey:"band", scene:"success", sel:"synth",
+  pkey:null, scene:"empty", sel:null,
   playing:false, pos:0 /*bars*/, muted:new Set(), solo:new Set(),
   itab:"instrument", zoom:1, barPx:16, showWave:true, showGrid:true,
   url:"", liveProject:null, liveSid:null,
+  focusStem:null,
+  playMode:"wav",  // "wav" | "midi"
 };
-let raf=null, lastT=0;
-const P = ()=>STATE.liveProject || PROJECTS[STATE.pkey];
-function totalBars(){ const p=P(); return Math.ceil(p.duration*p.tempo/60/p.timeSig[0]); }
+let raf=null, lastT=0, _progScrollLeft=-1;
+const P = ()=>STATE.liveProject || PROJECTS[STATE.pkey] || null;
+function totalBars(){ const p=P(); if(!p) return 0; return Math.ceil(p.duration*p.tempo/60/p.timeSig[0]); }
+function _calcBars(){ return Math.max(4, Math.min(32, Math.floor((document.getElementById("score-systems")?.clientWidth||800)/120))); }
+
+// ── SVG staff cache — avoids re-rendering notation on scroll/mute/zoom ──────
+let _staffCacheVer = 0;
+const _staffCache = new Map(); // "${ver}|${stemId}|${barOffset}|${key}" → SVGElement
+function _cachedStaff(s, p) {
+  const key = `${_staffCacheVer}|${s.id}|${p.barOffset}|${p.key}`;
+  if (_staffCache.has(key)) return _staffCache.get(key).cloneNode(true);
+  const svg = renderStaff(s, p, {salt:0});
+  _staffCache.set(key, svg);
+  if (_staffCache.size > 300) _staffCache.delete(_staffCache.keys().next().value); // LRU evict
+  return svg.cloneNode(true);
+}
+function _invalidateStaffCache() { _staffCacheVer++; _staffCache.clear(); }
 
 /* ---------------- TOP / SUB META ---------------- */
 function renderMeta(){
-  const p=P();
-  if(document.activeElement!==$("#omni-input")) $("#omni-input").value = p.source?.startsWith("http") ? p.source : "https://"+p.source;
-  $("#crumb-title").textContent = p.title;
-  $("#gpu-bar").style.width=p.gpu.util+"%"; $("#gpu-val").textContent=p.gpu.util+"%";
-  const vr=p.gpu.vramTotal>0?Math.round(p.gpu.vram/p.gpu.vramTotal*100):0;
-  $("#vram-bar").style.width=vr+"%"; $("#vram-val").textContent=p.gpu.vramTotal>0?p.gpu.vram.toFixed(1)+"G":"—";
-  $("#gpu-bar").style.background = p.gpu.util>60?"linear-gradient(90deg,var(--warn),var(--play))":"linear-gradient(90deg,var(--acc),var(--acc-bright))";
+  const p=P(); if(!p) return;
+  if(document.activeElement!==$("#omni-input")) $("#omni-input").value = p.source?.startsWith("http") ? p.source : "";
+  $("#crumb-title").textContent=p.title;
+  $("#crumb-sep").style.display="";
+  $("#sbar-dot").style.background="var(--good)";
+  $("#sbar-model").textContent=p.sepModel.split(" · ")[0];
+  const midiTot=p.stems.reduce((a,s)=>a+s.midi,0);
+  $("#sbar-stems").textContent=p.stems.length+" stems · "+midiTot.toLocaleString()+" MIDI events";
+  $("#sbar-fmt").textContent=`${p.sampleRate/1000} kHz · ${p.bitDepth}-bit`;
   $("#sub-meta").innerHTML =
     `<span><span class="k">tempo</span> <b>${p.tempo}</b></span>`+
     `<span><span class="k">key</span> <b>${p.key}</b></span>`+
@@ -64,55 +83,32 @@ function renderMeta(){
   $("#st-tempo").innerHTML=`${p.tempo} <small>BPM</small>`;
   $("#st-sig").textContent=p.timeSig.join("/");
   $("#st-key").textContent=p.key.replace(" minor"," min").replace(" major"," maj");
-  $("#sbar-model").textContent=p.sepModel.split(" · ")[0];
-  const midiTot=p.stems.reduce((a,s)=>a+s.midi,0);
-  $("#sbar-stems").textContent=p.stems.length+" stems";
-  $("#sbar-midi").textContent=midiTot.toLocaleString()+" MIDI events";
-  $(".status .sb.right").textContent=`${(p.sampleRate/1000)} kHz · ${p.bitDepth}-bit`;
 }
 
 /* ---------------- LEFT ---------------- */
 function renderLeft(){
   const p=P();
-  // navigator: projects as expandable; current expanded showing stems
-  const projs=Object.values(PROJECTS);
-  $("#nav-count").textContent=projs.length;
-  $("#nav-tree").innerHTML = projs.map(pr=>{
-    const open=pr.id===STATE.pkey;
-    const head=`<div class="trow ${open?'active':''}" data-load="${pr.id}">
-      <span class="tw">${svgIco(open?'<path d="M6 9l6 6 6-6"/>':'<path d="M9 6l6 6-6 6"/>')}</span>
-      <span class="nm">${pr.title}</span><span class="meta">${pr.stems.length}</span></div>`;
-    let kids="";
-    if(open){ kids=pr.stems.map(s=>`<div class="trow indent" data-stem="${s.id}">
-       <span class="swatch" style="background:var(${s.color})"></span>
-       <span class="nm">${s.name}</span><span class="meta">${Math.round(s.confidence)}%</span></div>`).join(""); }
-    return head+kids;
-  }).join("");
-  // files
-  $("#file-tree").innerHTML = [
-    {t:"📁 source.wav",m:fmtSize(p),f:1},
-    {t:"📁 stems/",m:p.stems.length,f:1},
-  ].map(()=>"").join("") +
-  `<div class="trow"><span class="tw">${svgIco('<path d="M14 2v6h6"/><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z"/>')}</span><span class="nm">source_master.wav</span><span class="meta">${fmtSize(p)}</span></div>`+
-  p.stems.map(s=>`<div class="trow indent"><span class="tw" style="color:var(${s.color})">${svgIco('<path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="2.5"/><circle cx="18" cy="16" r="2.5"/>')}</span><span class="nm">${s.id}.mid</span><span class="meta">${s.midi||'—'}</span></div>`).join("")+
-  `<div class="trow"><span class="tw">${svgIco('<path d="M14 2v6h6"/><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z"/>')}</span><span class="nm">${p.id}_score.musicxml</span><span class="meta">XML</span></div>`;
-  // history
-  const hist=[
-    {p:"band",t:"2m ago"},{p:"orchestra",t:"1h ago"},{p:"piano",t:"3h ago"},
-    {p:"band",t:"yesterday",alt:"Saffron Light — Loom"},{p:"orchestra",t:"2d ago",alt:"Concerto in E — Aria"},
-  ];
-  $("#hist-count").textContent=hist.length;
-  $("#hist-list").innerHTML=hist.map(h=>{const pr=PROJECTS[h.p];return `<div class="hist-item" data-load="${h.p}">
-    <div class="thumb" style="background:${pr.thumb}"></div>
-    <div class="hi-main"><div class="hi-t">${h.alt||pr.title}</div><div class="hi-s">${pr.stems.length} stems · ${pr.key}</div></div>
-    <div class="hi-time">${h.t}</div></div>`;}).join("");
+  if(!p){
+    $("#nav-count").textContent="";
+    $("#nav-tree").innerHTML='<div class="nav-empty-msg">No project open</div>';
+    return;
+  }
+  $("#nav-count").textContent=p.stems.length;
+  $("#nav-tree").innerHTML=
+    `<div class="proj-title-row">${p.title}</div>`+
+    p.stems.map(s=>`<div class="trow indent${s.id===STATE.sel?' active':''}" data-stem="${s.id}">
+      <span class="swatch" style="background:var(${s.color})"></span>
+      <span class="nm">${s.name}</span>
+      <span class="meta">${Math.round(s.confidence)}%</span>
+    </div>`).join("");
 }
 
 /* ---------------- SCORE ---------------- */
 function renderScore(){
-  const p=P();
+  const p=P(); if(!p) return;
+  const tb=totalBars();
   $("#score-title").innerHTML=`<h1>${p.title}</h1>
-    <div class="sub"><span><b>${p.artist}</b></span><span>${p.key}</span><span>♩ = ${p.tempo}</span><span>${p.timeSig.join("/")}</span><span>bars ${p.barOffset}–${p.barOffset+p.bars-1}</span><span>${p.transModel}</span></div>`;
+    <div class="sub"><span><b>${p.artist}</b></span><span>${p.key}</span><span>♩ = ${p.tempo}</span><span>${p.timeSig.join("/")}</span><span>${p.transModel}</span></div>`;
   const wrap=$("#score-systems"); wrap.innerHTML="";
   const solo=STATE.solo.size>0;
   p.stems.forEach(s=>{
@@ -126,17 +122,32 @@ function renderScore(){
         <div class="sl-top"><span class="sl-dot" style="background:var(${s.color})"></span><span class="sl-name">${s.name}</span></div>
         <div class="sl-sub"><span>${clefName(s.clef)}</span><span class="conf-mini"><i style="background:${cc}"></i>${s.confidence.toFixed(1)}%</span>${s.removed?'<span style="color:var(--bad)">muted</span>':''}</div>
       </div><div class="staff-svg-wrap"></div>`;
-    const svg=renderStaff(s,p,{salt:0});
+    const svg=_cachedStaff(s,p);
     row.querySelector(".staff-svg-wrap").appendChild(svg);
     wrap.appendChild(row);
   });
+  // bar nav
+  const nav=document.getElementById("score-nav");
+  const lbl=document.getElementById("score-nav-label");
+  const prev=document.getElementById("score-prev");
+  const next=document.getElementById("score-next");
+  if(nav){ nav.style.display=tb>p.bars?"flex":"none"; }
+  if(lbl){ lbl.textContent=`Bars ${p.barOffset+1}–${Math.min(p.barOffset+p.bars,tb)}`; }
+  if(prev){ prev.disabled=p.barOffset<=0; }
+  if(next){ next.disabled=p.barOffset+p.bars>=tb; }
   applyZoom();
 }
+function scoreNavStep(dir){
+  const p=P(); if(!p) return;
+  const tb=totalBars();
+  p.barOffset=Math.max(0,Math.min(tb-p.bars, p.barOffset+dir*p.bars));
+  renderScore();
+}
 function clefName(c){return {treble:"Treble",bass:"Bass",alto:"Alto",perc:"Perc"}[c]||c;}
 
 /* ---------------- TIMELINE ---------------- */
 function renderTimeline(){
-  const p=P(); const beats=p.timeSig[0]; const tb=totalBars(); const bpx=STATE.barPx;
+  const p=P(); if(!p) return; const beats=p.timeSig[0]; const tb=totalBars(); const bpx=STATE.barPx;
   // gutter
   const solo=STATE.solo.size>0;
   $("#gutter").innerHTML=p.stems.map(s=>{
@@ -154,28 +165,42 @@ function renderTimeline(){
   const grid=$("#grid-canvas");
   drawGrid(grid, tb, bpx, beats, p.stems.length*laneH);
   grid.style.display=STATE.showGrid?"block":"none";
-  // lanes
-  const lanes=$("#lanes"); lanes.innerHTML="";
+  // lanes — reuse existing canvas elements when stem list + dimensions unchanged
+  const lanes=$("#lanes");
   const W=tb*bpx;
   $("#lanes-wrap").style.width=W+"px";
   $("#ruler").style.width=W+"px";
   $("#lane-col").style.width=W+"px";
-  // reserve gutter footer = horizontal scrollbar height so rows stay aligned at bottom
   const sb=$("#lane-scroll").offsetHeight-$("#lane-scroll").clientHeight;
   $("#gutter-foot").style.height=Math.max(0,sb)+"px";
-  p.stems.forEach(s=>{
-    const lane=document.createElement("div"); lane.className="lane"; lane.dataset.stem=s.id;
-    const cv=document.createElement("canvas"); lane.appendChild(cv);
-    lanes.appendChild(lane);
-    if(STATE.showWave) drawWaveform(cv, {...s, muted:STATE.muted.has(s.id)||(solo&&!STATE.solo.has(s.id))}, {width:W,height:laneH,beatPx:bpx/beats});
-    else cv.style.display="none";
+  const existingLanes=[...lanes.children];
+  const stemIds=p.stems.map(s=>s.id).join(",");
+  const existingIds=existingLanes.map(l=>l.dataset.stem).join(",");
+  if(stemIds!==existingIds) lanes.innerHTML=""; // stem structure changed — full rebuild
+  p.stems.forEach((s,i)=>{
+    let lane=lanes.children[i];
+    let cv;
+    if(!lane){
+      lane=document.createElement("div"); lane.className="lane"; lane.dataset.stem=s.id;
+      cv=document.createElement("canvas"); lane.appendChild(cv);
+      lanes.appendChild(lane);
+    } else {
+      cv=lane.querySelector("canvas");
+    }
+    if(STATE.showWave){
+      const peaks=AudioEngine.hasStem(s.id)?AudioEngine.getPeaks(s.id):null;
+      drawWaveform(cv,{...s,muted:STATE.muted.has(s.id)||(solo&&!STATE.solo.has(s.id))},{width:W,height:laneH,beatPx:bpx/beats,peaks});
+      cv.style.display="";
+    } else {
+      cv.style.display="none";
+    }
   });
   positionPlayhead();
 }
 
 /* ---------------- INSPECTOR ---------------- */
 function renderInspector(){
-  const p=P(); const s=p.stems.find(x=>x.id===STATE.sel)||p.stems[0];
+  const p=P(); if(!p) return; const s=p.stems.find(x=>x.id===STATE.sel)||p.stems[0];
   const body=$("#insp-body");
   if(STATE.itab==="instrument") body.innerHTML=inspInstrument(p,s);
   else if(STATE.itab==="quality") body.innerHTML=inspQuality(p,s);
@@ -209,10 +234,6 @@ function inspInstrument(p,s){
     <div class="metric"><div class="ml"><span class="k">Register</span><span class="v">${regName(s)}</span></div></div>
     <div class="metric"><div class="ml"><span class="k">Polyphony</span><span class="v">${/key|pno|pad|harp|guitar/.test(s.id)?'poly':'mono'}</span></div></div>
     <div class="metric"><div class="ml"><span class="k">Role</span><span class="v">${s.role||'—'}</span></div></div>
-  </div>
-  <div class="isec">
-    <div class="isec-h"><span class="ico" style="color:var(--acc-bright)">${svgIco('<path d="M12 2v4M12 18v4M4.9 4.9l2.8 2.8M16.3 16.3l2.8 2.8M2 12h4M18 12h4M4.9 19.1l2.8-2.8M16.3 7.7l2.8-2.8"/>')}</span>AI Diagnostics<span class="more">${p.stems.length} sources</span></div>
-    <div class="diag">${p.diagnostics.map(d=>diagRow(d)).join("")}</div>
   </div>`;
 }
 function inspQuality(p,s){
@@ -227,8 +248,6 @@ function inspQuality(p,s){
   <div class="isec">
     <div class="isec-h"><span class="ico">${svgIco('<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>')}</span>Separation summary</div>
     ${metric("Overall confidence",overall,overall.toFixed(1)+"%",confColor(overall))}
-    ${metric("Phase coherence",94.2,"94.2%",'var(--good)')}
-    ${metric("Reconstruction error",8,"−24.1 dB",'var(--acc)',true)}
   </div>
   <div class="isec">
     <div class="isec-h"><span class="ico">${svgIco('<path d="M3 3v18h18"/><rect x="7" y="10" width="3" height="8"/><rect x="13" y="6" width="3" height="12"/>')}</span>Per-stem confidence</div>
@@ -265,13 +284,6 @@ function metric(k,pct,v,col,inverse){
   return `<div class="metric"><div class="ml"><span class="k">${k}</span><span class="v">${v}</span></div>
     <div class="track"><i style="width:${Math.max(2,Math.min(100,pct))}%;background:${col}"></i></div></div>`;
 }
-function diagRow(d){
-  const ic={ok:'<path d="M20 6 9 17l-5-5"/>',warn:'<path d="M12 9v4M12 17h.01M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z"/>',err:'<circle cx="12" cy="12" r="9"/><path d="M15 9l-6 6M9 9l6 6"/>',info:'<circle cx="12" cy="12" r="9"/><path d="M12 16v-4M12 8h.01"/>'}[d.sev];
-  const col={ok:'var(--good)',warn:'var(--warn)',err:'var(--bad)',info:'var(--acc-bright)'}[d.sev];
-  return `<div class="diag-row"><span class="diag-ic" style="color:${col}">${svgIco(ic)}</span>
-    <div class="diag-main"><div class="dt">${d.t}</div><div class="ds">${d.s}</div></div>
-    <div class="diag-val" style="color:${col}">${d.v}</div></div>`;
-}
 
 /* ---------------- helpers ---------------- */
 function confColor(c){ return c>=90?'var(--good)':c>=78?'var(--warn)':'var(--bad)'; }
@@ -292,8 +304,13 @@ function applyZoom(){
 function positionPlayhead(){
   const bpx=STATE.barPx;
   $("#playhead").style.left=(STATE.pos*bpx)+"px";
-  // timecode
-  const p=P(); const beats=p.timeSig[0];
+  const p=P();
+  if(!p){
+    $("#tc-bars").textContent="001"; $("#tc-beat").textContent="1";
+    $("#tc-tick").textContent="00"; $("#tc-time").textContent="0:00.0";
+    return;
+  }
+  const beats=p.timeSig[0];
   const bar=Math.floor(STATE.pos)+1, beat=Math.floor((STATE.pos%1)*beats)+1, tick=Math.floor(((STATE.pos%1)*beats%1)*100);
   $("#tc-bars").textContent=String(bar).padStart(3,"0");
   $("#tc-beat").textContent=beat;
@@ -303,27 +320,78 @@ function positionPlayhead(){
 }
 function tick(t){
   if(!STATE.playing){ raf=null; return; }
-  if(!lastT)lastT=t; const dt=(t-lastT)/1000; lastT=t;
-  const p=P(); const barsPerSec=p.tempo/60/p.timeSig[0];
-  STATE.pos+=barsPerSec*dt;
+  const p=P(); if(!p){ STATE.playing=false; raf=null; return; }
+  const beats=p.timeSig[0], bps=p.tempo/60/beats;
+  const eng = _activeEngine();
+  if(eng.isLoaded()){
+    STATE.pos=eng.currentSecs()*bps;
+  } else {
+    if(!lastT) lastT=t;
+    STATE.pos+=bps*(t-lastT)/1000;
+  }
+  lastT=t;
   if(STATE.pos>=totalBars()){ STATE.pos=0; }
   positionPlayhead();
-  // autoscroll lane
-  const sc=$("#lane-scroll"); const x=STATE.pos*STATE.barPx;
-  if(x>sc.scrollLeft+sc.clientWidth-120||x<sc.scrollLeft) sc.scrollLeft=x-120;
+  // auto-follow score to playhead
+  if(p && STATE.playing){
+    const bar=Math.floor(STATE.pos);
+    if(bar < p.barOffset || bar >= p.barOffset + p.bars){
+      p.barOffset=Math.max(0, Math.min(totalBars()-p.bars, Math.floor(bar/p.bars)*p.bars));
+      renderScore();
+    }
+  }
+  if(STATE.focusStem){
+    const secs=eng.isLoaded()?eng.currentSecs():barsToSecs(STATE.pos);
+    const fph=document.getElementById("focus-ph");
+    if(fph) fph.style.left=Math.min(100,secs/Math.max(1,p.duration)*100)+"%";
+  }
+  const sc=$("#lane-scroll"), x=STATE.pos*STATE.barPx;
+  if(x>sc.scrollLeft+sc.clientWidth-120||x<sc.scrollLeft){
+    _progScrollLeft=x-120; sc.scrollLeft=x-120;
+  }
   raf=requestAnimationFrame(tick);
 }
-function barsToSecs(bars){ const p=P(); return bars*p.timeSig[0]*60/p.tempo; }
+function barsToSecs(bars){ const p=P(); if(!p) return 0; return bars*p.timeSig[0]*60/p.tempo; }
+function _activeEngine(){ return STATE.playMode==="midi" ? MidiEngine : AudioEngine; }
 function setPlaying(v){
   STATE.playing=v; lastT=0;
   $("#play-ico").innerHTML = v?'<rect x="6" y="5" width="4" height="14" rx="1"/><rect x="14" y="5" width="4" height="14" rx="1"/>':'<path d="M7 4l13 8-13 8z"/>';
-  if(v){ if(AudioEngine.isLoaded()) AudioEngine.start(barsToSecs(STATE.pos)); if(!raf) raf=requestAnimationFrame(tick); }
-  else { AudioEngine.stop(); }
+  const eng = _activeEngine();
+  if(v){ if(eng.isLoaded()) eng.start(barsToSecs(STATE.pos)); if(!raf) raf=requestAnimationFrame(tick); }
+  else { eng.stop(); }
+}
+
+/* ---------------- FOCUS TRACK ---------------- */
+function openFocusTrack(stemId){
+  const p=P(); if(!p) return;
+  const s=p.stems.find(x=>x.id===stemId); if(!s) return;
+  STATE.focusStem=stemId;
+  STATE.solo=new Set([stemId]);
+  _activeEngine().setSolo([stemId]);
+  document.getElementById("focus-dot").style.background="var("+s.color+")";
+  document.getElementById("focus-name").textContent=s.name;
+  document.getElementById("focus-info").textContent=s.instrument+(s.midi?" · "+s.midi+" notes":"");
+  const wrap=document.getElementById("focus-wave-wrap");
+  const cv=document.getElementById("focus-wave-cv");
+  const W=wrap.clientWidth||Math.max(600,window.innerWidth-32);
+  cv.width=W; cv.height=80;
+  cv.style.width=W+"px"; cv.style.height="80px";
+  const focusPeaks = AudioEngine.hasStem(stemId) ? AudioEngine.getPeaks(stemId) : null;
+  drawWaveform(cv,{...s,muted:false},{width:W,height:80,beatPx:STATE.barPx/p.timeSig[0],peaks:focusPeaks});
+  document.getElementById("ov-focus").classList.add("show");
+  renderTimeline();
+}
+function closeFocusTrack(){
+  STATE.focusStem=null;
+  STATE.solo=new Set();
+  _activeEngine().setSolo([]);
+  document.getElementById("ov-focus").classList.remove("show");
+  renderTimeline();
 }
 
 /* ---------------- SELECTION ---------------- */
 function selectStem(id){
-  STATE.sel=id; const s=P().stems.find(x=>x.id===id);
+  const p=P(); if(!p) return; STATE.sel=id; const s=p.stems.find(x=>x.id===id);
   $$(".staff-row").forEach(r=>r.classList.toggle("sel",r.dataset.stem===id));
   $$(".gutter-track").forEach(r=>r.style.background=r.dataset.stem===id?"var(--bg-3)":"");
   $$('#nav-tree .trow.indent').forEach(r=>r.classList.toggle("active",r.dataset.stem===id));
@@ -341,12 +409,23 @@ const SCENES={
 };
 function setScene(scene){
   STATE.scene=scene; document.body.dataset.scene=scene;
+  if(scene==="processing" && STATE.focusStem) closeFocusTrack();
   $$(".overlay").forEach(o=>o.classList.remove("show"));
+  if(scene==="empty"){
+    STATE.pos=0; positionPlayhead();
+    $("#crumb-title").textContent=""; $("#crumb-sep").style.display="none";
+    $("#sub-meta").innerHTML="";
+    $("#st-tempo").textContent="—"; $("#st-sig").textContent="—"; $("#st-key").textContent="—";
+    $("#sbar-model").textContent="—"; $("#sbar-stems").textContent="—"; $("#sbar-sel").textContent="—";
+    $("#sbar-dot").style.background="var(--t-3)"; $("#sbar-fmt").textContent="";
+    $("#nav-tree").innerHTML='<div class="nav-empty-msg">No project open</div>';
+    $("#nav-count").textContent="";
+  }
   const cfg=SCENES[scene];
   if(cfg.ovr) $("#"+cfg.ovr).classList.add("show");
   const pill=$("#scene-pill"); pill.className="pill "+(cfg.pill[0]||"");
   $("#scene-pill-t").textContent=cfg.pill[1];
-  $("#crumb-dot").style.background = scene==="error"?"var(--bad)":scene==="success"?"var(--good)":"var(--warn)";
+  $("#crumb-dot").style.background = scene==="error"?"var(--bad)":scene==="success"?"var(--good)":scene==="empty"?"var(--t-3)":"var(--warn)";
   $("#sbar-scene").textContent=cfg.sbar;
   if(scene==="processing") runProcessing();
   if(scene==="error") fillErrorLog();
@@ -354,6 +433,7 @@ function setScene(scene){
 }
 function loadProject(key,scene){
   STATE.pkey=key; const p=P();
+  if(!p){ setScene("empty"); return; }
   STATE.sel=p.stems.find(s=>!s.removed)?.id||p.stems[0].id;
   STATE.muted=new Set(); STATE.solo=new Set(); STATE.pos=p.barOffset||5;
   document.body.dataset.project=key;
@@ -362,8 +442,15 @@ function loadProject(key,scene){
   renderAll();
   setScene(scene||"success");
   selectStem(STATE.sel);
+  _saveSession(); // save on project open
 }
-function renderAll(){ renderMeta(); renderLeft(); renderScore(); renderTimeline(); renderInspector(); positionPlayhead(); }
+function renderAll(){
+  if(!P()) return;
+  if(STATE.focusStem && !P().stems.find(s=>s.id===STATE.focusStem)) closeFocusTrack();
+  renderMeta(); renderLeft(); renderScore(); renderTimeline(); renderInspector(); positionPlayhead();
+}
+
+let _activePoll = null;
 
 /* processing animation */
 const PSTAGES=[
@@ -388,39 +475,67 @@ function _renderProcStages(prog, stageIdx){
   $("#proc-bar-i").style.width=pct+"%";
 }
 async function runProcessing(){
+  clearInterval(_activePoll); _activePoll = null;
+  clearInterval(procTimer);
   const host=$("#proc-stages");
   host.innerHTML=PSTAGES.map((s,i)=>`<div class="pstage pending" data-i="${i}">
     <span class="pst-ic">${svgIco(s.ic)}</span><span class="pst-name">${s.n}</span><span class="pst-meta"></span></div>`).join("");
-  clearInterval(procTimer);
+  $("#proc-pct").textContent="0%"; $("#proc-bar-i").style.width="0%";
+  // reset title unless local file already set it
+  if(!STATE.url.startsWith("local:")){ $("#proc-tt").textContent="Fetching…"; $("#proc-ts").textContent=""; }
 
   // Try real backend; fall back to demo simulation if unavailable
   if(STATE.url && STATE.url.startsWith("http")){
     try {
-      const r = await fetch("/api/analyze",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({url:STATE.url})});
+      const r = await fetch(_api("/api/analyze"),{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({url:STATE.url,force:!!STATE._forceReanalyze})});
       if(!r.ok) throw new Error("Server "+r.status);
       const {session_id} = await r.json();
       flash("Analyzing…  session "+session_id.slice(0,8));
 
-      const poll = setInterval(async ()=>{
-        if(STATE.scene!=="processing"){ clearInterval(poll); return; }
+      _activePoll = setInterval(async ()=>{
+        if(STATE.scene!=="processing"){ clearInterval(_activePoll); _activePoll=null; return; }
         let job;
-        try { job = await fetch(`/api/status/${session_id}`).then(x=>x.json()); }
+        try {
+          const _sr = await fetch(_api(`/api/status/${session_id}`));
+          if(_sr.status===404){
+            const _rr = await fetch(_api(`/api/resume/${session_id}`),{method:"POST"});
+            if(_rr.ok){ flash("Resuming from cached audio…"); return; }
+            clearInterval(_activePoll); _activePoll=null;
+            fillErrorLog("Session lost — please resubmit URL");
+            setScene("error"); return;
+          }
+          job = await _sr.json();
+        }
         catch(_){ return; }
 
+        if(job.status==="error"){
+          clearInterval(_activePoll); _activePoll=null;
+          fillErrorLog(job.error||"Unknown error");
+          setScene("error");
+          return;
+        }
+
+        if(job.meta?.title && job.meta.title!=="Unknown"){
+          $("#proc-tt").textContent=job.meta.title;
+          const dur=job.meta.duration?` · ${fmtTime(job.meta.duration)}`:"";
+          const art=job.meta.artist&&job.meta.artist!=="Unknown"?job.meta.artist:"";
+          $("#proc-ts").textContent=art+dur;
+        }
         const prog = job.progress||0;
         const si   = job.stage>=0 ? job.stage : 0;
         _renderProcStages(prog, si);
         $("#proc-eta").textContent = prog>=1?"Finalizing…":"Processing locally…";
-        $("#proc-gpu").textContent = job.meta?.gpu ? `GPU ${job.meta.gpu.util}% · ${job.meta.gpu.model}` : "GPU — local";
 
         if(job.status==="done"){
-          clearInterval(poll);
+          clearInterval(_activePoll); _activePoll=null;
           const m = job.meta||{};
           const stems = (job.stems||[]).map(s=>({
             ...s,
             density: s.density||2,
             seed: typeof s.seed==='number' ? s.seed : (s.id.split('').reduce((a,c)=>a*31+c.charCodeAt(0),1)&0x7fffffff)%50000,
             reg: s.reg||null,
+            audio_url: s.audio_url ? _api(s.audio_url) : s.audio_url,
+            midi_url:  s.midi_url  ? _api(s.midi_url)  : s.midi_url,
           }));
           STATE.liveProject = {
             id:"live", kind:"live",
@@ -431,25 +546,28 @@ async function runProcessing(){
             sampleRate: m.sampleRate||44100, bitDepth: m.bitDepth||24,
             sepModel: m.sepModel||"HT-Demucs v4", transModel: m.transModel||"librosa-pyin",
             gpu: m.gpu||{model:"CPU",util:0,vram:0,vramTotal:0},
-            bars:8, barOffset:0,
-            stems, diagnostics:[], spectrum:[],
+            bars:_calcBars(), barOffset:0,
+            stems, diagnostics:[], spectrum: m.spectrum||[],
           };
           STATE.pkey="live";
           STATE.liveSid=session_id;
+          STATE.sel=stems.find(s=>!s.removed)?.id||stems[0]?.id||null;
           if(stems.length){
-            flash("Loading stems…");
-            await Promise.all([
-              AudioEngine.loadFromSession(stems, (p,id,ok)=>{ if(!ok) flash("Failed: "+id); }),
-              _loadMidiNotes(session_id, STATE.liveProject.stems),
-            ]);
-            flash("Stems + MIDI loaded — press Space to play");
+            flash("Loading score…");
+            await _loadMidiNotes(session_id, STATE.liveProject.stems);
           }
+          // persist to recent + save session for cross-reload restore
+          if (m.title && STATE.url?.startsWith("http")) {
+            _pushRecent({ url: STATE.url, title: m.title, artist: m.artist || "", thumb: m.thumb || "", sid: session_id });
+          }
+          MidiEngine.reload(STATE.liveProject.stems);
+          _invalidateStaffCache();
           renderAll();
           setTimeout(()=>{ if(STATE.scene==="processing") setScene("success"); },300);
-        } else if(job.status==="error"){
-          clearInterval(poll);
-          fillErrorLog(job.error||"Unknown error");
-          setScene("error");
+          if(stems.length){
+            AudioEngine.loadFromSession(stems,(p,id,ok)=>{ if(!ok) flash("Failed: "+id); })
+              .then(()=>flash("Audio ready · Space to play"));
+          }
         }
       }, 800);
       return;
@@ -469,7 +587,6 @@ async function runProcessing(){
     for(let i=0;i<dur.length;i++){ acc+=dur[i]; if(el<acc){active=i;break;} active=dur.length; }
     _renderProcStages(prog,active);
     $("#proc-eta").textContent= prog>=1?"Finalizing…":("~"+Math.ceil((tot-el))+"s remaining");
-    $("#proc-gpu").textContent=`GPU ${Math.round(40+Math.random()*55)}% · RTX 4090`;
     if(prog>=1){ clearInterval(procTimer); setTimeout(()=>{ if(STATE.scene==="processing") setScene("success"); },650); }
   };
   procTimer=setInterval(tickP,80); tickP();
@@ -499,9 +616,6 @@ function hideCtx(){ $("#ctx").classList.remove("show"); }
 
 /* ---------------- COMMAND PALETTE ---------------- */
 const CMDS=[
-  {g:"Projects",t:"Open · Midnight Cartography",s:"band",ic:ICONS.synth,act:()=>loadProject("band")},
-  {g:"Projects",t:"Open · Aurora Borealis Suite",s:"14 stems",ic:ICONS.strings,act:()=>loadProject("orchestra")},
-  {g:"Projects",t:"Open · Gymnopédie No. 1",s:"solo piano",ic:ICONS.keys,act:()=>loadProject("piano")},
   {g:"States",t:"Show empty state",ic:'<rect x="3" y="3" width="18" height="18" rx="2"/>',act:()=>setScene("empty")},
   {g:"States",t:"Simulate new analysis (processing)",ic:'<path d="M12 2v4M12 18v4M2 12h4M18 12h4"/>',act:()=>setScene("processing")},
   {g:"States",t:"Show error state",ic:'<path d="M12 9v4M12 17h.01"/>',act:()=>setScene("error")},
@@ -531,17 +645,22 @@ function flash(msg){ $("#flash-t").textContent=msg; $("#flash").classList.add("s
 
 /* ---------------- MIDI NOTE LOADER ---------------- */
 async function _loadMidiNotes(sid, stems){
+  // Pre-init to [] so export knows "fetched but empty" vs "never attempted"
+  stems.forEach(s => { if(s.midi_url && s.clef!=="perc") s.midiNotes = s.midiNotes || []; });
   await Promise.allSettled(stems.map(async s => {
     if(!s.midi_url || s.clef==="perc") return;
     try {
-      const r = await fetch(`/api/midi/${sid}/${s.id}`);
+      const r = await fetch(_api(`/api/midi/${sid}/${s.id}`));
       if(r.ok){ const d=await r.json(); s.midiNotes=d.notes||[]; }
+      // non-OK → keep [] so export still works (score will show rests)
     } catch(_){}
   }));
 }
 
 /* ---------------- LOCAL FILE UPLOAD ---------------- */
 async function submitLocalFile(file){
+  if(STATE.scene==="processing") return;
+  clearInterval(_activePoll); _activePoll=null;
   STATE.liveProject=null;
   STATE.url="local:"+file.name;
   setScene("processing");
@@ -552,7 +671,7 @@ async function submitLocalFile(file){
   fd.append("file",file);
   let sid;
   try {
-    const r=await fetch("/api/upload",{method:"POST",body:fd});
+    const r=await fetch(_api("/api/upload"),{method:"POST",body:fd});
     if(!r.ok) throw new Error("Upload failed "+r.status);
     ({session_id:sid}=await r.json());
   } catch(e) {
@@ -562,22 +681,31 @@ async function submitLocalFile(file){
   }
 
   flash("Uploading… session "+sid.slice(0,8));
-  const poll=setInterval(async()=>{
-    if(STATE.scene!=="processing"){clearInterval(poll);return;}
+  _activePoll=setInterval(async()=>{
+    if(STATE.scene!=="processing"){clearInterval(_activePoll);_activePoll=null;return;}
     let job;
-    try{job=await fetch(`/api/status/${sid}`).then(x=>x.json());}catch(_){return;}
+    try{job=await fetch(_api(`/api/status/${sid}`)).then(x=>x.json());}catch(_){return;}
+
+    if(job.status==="error"){
+      clearInterval(_activePoll);_activePoll=null;
+      fillErrorLog(job.error||"Unknown error");
+      setScene("error");
+      return;
+    }
+
     const prog=job.progress||0, si=job.stage>=0?job.stage:0;
     _renderProcStages(prog,si);
     $("#proc-eta").textContent=prog>=1?"Finalizing…":"Processing locally…";
-    $("#proc-gpu").textContent=job.meta?.gpu?`${job.meta.gpu.model}`:"CPU · local";
     if(job.status==="done"){
-      clearInterval(poll);
+      clearInterval(_activePoll);_activePoll=null;
       const m=job.meta||{};
       const stems=(job.stems||[]).map(s=>({
         ...s,
         density:s.density||2,
         seed:typeof s.seed==='number'?s.seed:(s.id.split('').reduce((a,c)=>a*31+c.charCodeAt(0),1)&0x7fffffff)%50000,
         reg:s.reg||null,
+        audio_url: s.audio_url ? _api(s.audio_url) : s.audio_url,
+        midi_url:  s.midi_url  ? _api(s.midi_url)  : s.midi_url,
       }));
       STATE.liveProject={
         id:"live",kind:"live",
@@ -588,28 +716,146 @@ async function submitLocalFile(file){
         sampleRate:m.sampleRate||44100,bitDepth:m.bitDepth||24,
         sepModel:m.sepModel||"HT-Demucs v4",transModel:m.transModel||"librosa-pyin",
         gpu:m.gpu||{model:"CPU",util:0,vram:0,vramTotal:0},
-        bars:8,barOffset:0,stems,diagnostics:[],spectrum:[],
+        bars:8,barOffset:0,stems,diagnostics:[],spectrum:m.spectrum||[],
       };
       STATE.pkey="live";
       STATE.liveSid=sid;
+      STATE.sel=stems.find(s=>!s.removed)?.id||stems[0]?.id||null;
       if(stems.length){
-        flash("Loading stems…");
-        await Promise.all([
-          AudioEngine.loadFromSession(stems,(p,id,ok)=>{if(!ok)flash("Failed: "+id);}),
-          _loadMidiNotes(sid, STATE.liveProject.stems),
-        ]);
-        flash("Stems + MIDI loaded — press Space to play");
+        flash("Loading score…");
+        await _loadMidiNotes(sid, STATE.liveProject.stems);
       }
+      MidiEngine.reload(STATE.liveProject.stems);
+      _invalidateStaffCache();
       renderAll();
       setTimeout(()=>{if(STATE.scene==="processing")setScene("success");},300);
-    } else if(job.status==="error"){
-      clearInterval(poll);
-      fillErrorLog(job.error||"Unknown error");
-      setScene("error");
+      if(stems.length){
+        AudioEngine.loadFromSession(stems,(p,id,ok)=>{if(!ok)flash("Failed: "+id);})
+          .then(()=>flash("Audio ready · Space to play"));
+      }
     }
   },800);
 }
 
+/* ---------------- URL SUBMIT (global so opener + omnibox + empty input all use it) ---------------- */
+function submitUrl(url, force=false){
+  if(STATE.scene==="processing") return;
+  STATE.url=(url||"").trim();
+  STATE._forceReanalyze=force;
+  STATE.liveProject=null;
+  setScene("processing");
+}
+
+/* ---------------- SESSION PERSISTENCE ────────────────────── */
+const _LS_SESSION = "aegis_session_v2";
+
+function _saveSession() {
+  const p = P(), sid = STATE.liveSid;
+  if (!p || !sid) return;
+  const slim = {
+    ...p,
+    stems: p.stems.map(({ midiNotes, ...s }) => s),
+    spectrum: [], diagnostics: [],
+  };
+  try { localStorage.setItem(_LS_SESSION, JSON.stringify({ sid, project: slim, ts: Date.now() })); } catch(_){}
+}
+
+async function _tryRestoreSession() {
+  try {
+    const raw = localStorage.getItem(_LS_SESSION);
+    if (!raw) return false;
+    const { sid, project, ts } = JSON.parse(raw);
+    if (!sid || !project) return false;
+    if (Date.now() - ts > 7 * 24 * 3600 * 1000) return false;  // 7-day TTL
+    const r = await fetch(_api(`/api/status/${sid}`));
+    if (!r.ok) return false;
+    const job = await r.json();
+    if (job.status !== "done") return false;
+    // Merge freshest stems from server (in case file paths changed)
+    const stems = (job.stems || project.stems || []).map(s => ({
+      ...s,
+      density: s.density || 2,
+      seed: typeof s.seed === "number" ? s.seed : 1,
+      reg: s.reg || null,
+      audio_url: s.audio_url ? _api(s.audio_url) : s.audio_url,
+      midi_url:  s.midi_url  ? _api(s.midi_url)  : s.midi_url,
+    }));
+    STATE.liveProject = { ...project, stems };
+    STATE.pkey = "live";
+    STATE.liveSid = sid;
+    STATE.sel = stems.find(s => !s.removed)?.id || stems[0]?.id || null;
+    flash("Restoring session…");
+    if (stems.length) {
+      await _loadMidiNotes(sid, STATE.liveProject.stems);
+      MidiEngine.reload(STATE.liveProject.stems);
+    }
+    renderAll();
+    setScene("success");
+    flash("Session restored — audio loading…");
+    if (stems.length) {
+      AudioEngine.loadFromSession(stems, (_, id, ok) => { if (!ok) flash("Audio failed: " + id); })
+        .then(() => flash("Audio ready · Space to play"));
+    }
+    return true;
+  } catch(_) { return false; }
+}
+
+async function _openRecentSession(entry) {
+  if (!entry) return;
+  setPlaying(false);
+  clearInterval(_activePoll); _activePoll = null;
+  STATE.url = entry.url || "";
+  if (entry.sid) {
+    setScene("loading");
+    try {
+      const r = await fetch(_api(`/api/status/${entry.sid}`));
+      if (r.ok) {
+        const job = await r.json();
+        if (job.status === "done") {
+          const m = job.meta || {};
+          const stems = (job.stems || []).map(s => ({
+            ...s, density: s.density||2,
+            seed: typeof s.seed==="number"?s.seed:1, reg: s.reg||null,
+            audio_url: s.audio_url ? _api(s.audio_url) : s.audio_url,
+            midi_url:  s.midi_url  ? _api(s.midi_url)  : s.midi_url,
+          }));
+          STATE.liveProject = {
+            id:"live", kind:"live",
+            title: m.title||entry.title||"Untitled",
+            artist: m.artist||entry.artist||"",
+            album:"", source: entry.url||"",
+            thumb: m.thumb?`url("${m.thumb}") center/cover`
+                         :"linear-gradient(135deg,oklch(0.4 0.12 260),oklch(0.5 0.1 200))",
+            duration: m.duration||180, tempo: m.tempo||120,
+            tempoMap:[[0,m.tempo||120]],
+            key: m.key||"A minor", timeSig: m.timeSig||[4,4],
+            sampleRate: m.sampleRate||44100, bitDepth: m.bitDepth||24,
+            sepModel: m.sepModel||"HT-Demucs v4", transModel: m.transModel||"basic-pitch",
+            gpu: m.gpu||{model:"CPU",util:0,vram:0,vramTotal:0},
+            bars:_calcBars(), barOffset:0,
+            stems, diagnostics:[], spectrum: m.spectrum||[],
+          };
+          STATE.pkey="live"; STATE.liveSid=entry.sid;
+          STATE.sel=stems.find(s=>!s.removed)?.id||stems[0]?.id||null;
+          flash("Loading score…");
+          if (stems.length) {
+            await _loadMidiNotes(entry.sid, STATE.liveProject.stems);
+            MidiEngine.reload(STATE.liveProject.stems);
+          }
+          _invalidateStaffCache(); renderAll(); setScene("success");
+          flash("Restored — audio loading…");
+          AudioEngine.loadFromSession(stems, (_,id,ok)=>{ if(!ok) flash("Audio: "+id+" failed"); })
+            .then(()=>flash("Audio ready · Space to play"));
+          _saveSession();
+          return;
+        }
+      }
+    } catch(_) {}
+  }
+  if (entry.url) submitUrl(entry.url);
+  else flash("Cannot open: no URL stored");
+}
+
 /* ---------------- EVENTS ---------------- */
 function bind(){
   // File picker wired to hidden input
@@ -638,6 +884,18 @@ function bind(){
 
   document.addEventListener("click",e=>{
     const t=e.target;
+    const mb=t.closest("[data-menubar]"); if(mb){
+      const act=mb.dataset.menubar;
+      if(act==="analyze"){
+        const p=P();
+        if(p && STATE.url){ submitUrl(STATE.url, true); }         // re-run AI pipeline on same URL
+        else if(p){ flash("Drop a file or paste a URL to re-analyze"); $("#omni-input")?.focus(); }
+        else { setScene("empty"); }
+      }
+      else if(act==="score"){ document.querySelector('.tab[data-tab="score"]')?.click(); }
+      else if(act==="view"){ openCmdk(); }
+      return;
+    }
     const load=t.closest("[data-load]"); if(load){ loadProject(load.dataset.load, load.dataset.load && SCENES[load.dataset.load]?undefined:undefined); return; }
     const stemEl=t.closest("[data-stem]");
     const mute=t.closest("[data-mute]"); if(mute){ e.stopPropagation(); toggleMute(mute.dataset.mute); return; }
@@ -672,6 +930,25 @@ function bind(){
     const ci=t.closest(".cmdk-item"); if(ci&&ci.dataset.idx!=null){ runCmdk(+ci.dataset.idx); return; }
     if(t.closest("#btn-cmdk")){ openCmdk(); return; }
     if(t.id==="cmdk"){ closeCmdk(); return; }
+    // crumb title click → project actions menu
+    if(t.closest("#crumb-title")){
+      const p=P(); if(!p) return;
+      const r=t.closest("#crumb-title").getBoundingClientRect();
+      showCtx(r.left, r.bottom+4, [
+        { label: p.title },
+        { t:"Export stems as MIDI", ic:'<path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3"/>',
+          act:"flash:proj-export" },
+        { t:"Export stems as WAV",  ic:'<path d="M2 12h2l3-8 4 16 3-12 2 6h6"/>',
+          act:"flash:proj-export-wav" },
+        { t:"Detection log",        ic:'<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/>',
+          act:"proj:log" },
+        { sep:true },
+        { t:"Re-analyze",           ic:'<path d="M12 2v4M2 12h4"/>',
+          act:"proj:reanalyze" },
+        { t:"Close project",        ic:'<path d="M18 6L6 18M6 6l12 12"/>', danger:1,
+          act:"proj:close" },
+      ]); return;
+    }
     // scene pill menu
     if(t.closest("#scene-pill")){ const r=t.closest("#scene-pill").getBoundingClientRect(); showCtx(r.left,r.bottom+4,[
       {label:"Application states"},
@@ -679,14 +956,11 @@ function bind(){
       {t:"Empty",ic:'<rect x="3" y="3" width="18" height="18" rx="2"/>',act:"sc:empty"},
       {t:"Processing",ic:'<path d="M12 2v4M2 12h4"/>',act:"sc:processing"},
       {t:"Error",ic:'<path d="M12 9v4M12 17h.01"/>',act:"sc:error"},
-      {sep:1},{label:"Projects"},
-      {t:"Solo piano (small)",ic:ICONS.keys,act:"pj:piano"},
-      {t:"Orchestral (massive)",ic:ICONS.strings,act:"pj:orchestra"},
     ]); return; }
     hideCtx();
     // transport
     if(t.closest("#tp-play")) setPlaying(!STATE.playing);
-    if(t.closest("#tp-stop")){ setPlaying(false); STATE.pos=P().barOffset||0; positionPlayhead(); }
+    if(t.closest("#tp-stop")){ setPlaying(false); STATE.pos=P()?.barOffset||0; positionPlayhead(); }
     if(t.closest("#tp-start")){ STATE.pos=0; positionPlayhead(); $("#lane-scroll").scrollLeft=0; }
     if(t.closest("#tp-loop")) t.closest("#tp-loop").classList.toggle("on");
     // toggles
@@ -701,12 +975,36 @@ function bind(){
     if(t.closest(".er")){ const er=t.closest(".er"); loadProject(er.dataset.load,"processing"); return; }
     if(t.closest("#empty-go")){ const v=$("#empty-input").value.trim(); if(v){ submitUrl(v); } return; }
   });
-  // lane seek
-  $("#lane-scroll").addEventListener("mousedown",e=>{
-    if(e.target.closest(".playhead"))return;
+  // double-click gutter track or lane → focus player
+  document.addEventListener("dblclick",e=>{
+    const gt=e.target.closest(".gutter-track, .lane");
+    if(!gt) return;
+    e.preventDefault(); e.stopPropagation();
+    const id=gt.dataset.stem; if(!id) return;
+    if(id===STATE.focusStem) closeFocusTrack();
+    else openFocusTrack(id);
+  });
+  // focus panel controls
+  document.getElementById("focus-close").addEventListener("click",closeFocusTrack);
+  document.getElementById("focus-wave-wrap").addEventListener("click",e=>{
+    const p=P(); if(!p) return;
+    const rect=e.currentTarget.getBoundingClientRect();
+    const secs=Math.max(0,(e.clientX-rect.left)/rect.width)*p.duration;
+    STATE.pos=secs*p.tempo/60/p.timeSig[0];
+    const fph=document.getElementById("focus-ph");
+    if(fph) fph.style.left=Math.min(100,secs/Math.max(1,p.duration)*100)+"%";
+    positionPlayhead();
+    if(STATE.playing){ const eng=_activeEngine(); eng.stop(); eng.start(secs); }
+  });
+
+  // lane seek — ignore native horizontal scrollbar (lives below clientHeight)
+  $("#lane-scroll").addEventListener("mousedown",ev=>{
+    if(ev.target.closest(".playhead"))return;
+    const sc=ev.currentTarget;
+    if(ev.offsetY >= sc.clientHeight) return; // click is in native scrollbar area
     const wrap=$("#lanes-wrap"); const rect=wrap.getBoundingClientRect();
-    const x=e.clientX-rect.left; STATE.pos=Math.max(0,x/STATE.barPx); positionPlayhead();
-    if(STATE.playing){ AudioEngine.stop(); AudioEngine.start(barsToSecs(STATE.pos)); }
+    const x=ev.clientX-rect.left; STATE.pos=Math.max(0,x/STATE.barPx); positionPlayhead();
+    if(STATE.playing){ const eng=_activeEngine(); eng.stop(); eng.start(barsToSecs(STATE.pos)); }
   });
   // ruler seek
   $("#ruler").addEventListener("mousedown",e=>{ const r=e.currentTarget.getBoundingClientRect(); STATE.pos=Math.max(0,(e.clientX-r.left)/STATE.barPx); positionPlayhead(); });
@@ -714,6 +1012,22 @@ function bind(){
   const gv=$("#gutter-scroll"), lv=$("#lanes-vscroll"); let syncing=false;
   lv.addEventListener("scroll",()=>{ if(syncing)return; syncing=true; gv.scrollTop=lv.scrollTop; syncing=false; });
   gv.addEventListener("scroll",()=>{ if(syncing)return; syncing=true; lv.scrollTop=gv.scrollTop; syncing=false; });
+  // timeline horizontal scroll → sync score barOffset
+  // During playback tick() sets sc.scrollLeft programmatically — skip those events,
+  // only react to genuine user drags of the scrollbar.
+  let _scoreScrollRAF=null;
+  // _progScrollLeft is module-scoped (declared above tick) — shared with tick()
+  $("#lane-scroll").addEventListener("scroll",()=>{
+    const p=P(); if(!p) return;
+    const sl=$("#lane-scroll").scrollLeft;
+    if(Math.abs(sl-_progScrollLeft)<2) return; // tick()-driven scroll, ignore
+    if(_scoreScrollRAF) cancelAnimationFrame(_scoreScrollRAF);
+    _scoreScrollRAF=requestAnimationFrame(()=>{
+      const bar=Math.floor($("#lane-scroll").scrollLeft/STATE.barPx);
+      const newOff=Math.max(0,Math.min(totalBars()-p.bars,bar));
+      if(newOff!==p.barOffset){ p.barOffset=newOff; renderScore(); }
+    });
+  });
   // context menus
   document.addEventListener("contextmenu",e=>{
     const g=e.target.closest("[data-stem]");
@@ -741,7 +1055,6 @@ function bind(){
       ]); return; }
   });
   // omnibox enter
-  function submitUrl(url){ STATE.url=(url||"").trim(); STATE.liveProject=null; setScene("processing"); }
   $("#omni-input").addEventListener("keydown",e=>{ if(e.key==="Enter"){ e.target.blur(); submitUrl(e.target.value); }});
   $("#omni-input").addEventListener("blur",e=>{ STATE.url=(e.target.value||"").trim(); });
   $("#empty-input").addEventListener("keydown",e=>{ if(e.key==="Enter") submitUrl(e.target.value); });
@@ -759,9 +1072,9 @@ function bind(){
   // global keys
   document.addEventListener("keydown",e=>{
     if((e.metaKey||e.ctrlKey)&&e.key.toLowerCase()==="k"){ e.preventDefault(); openCmdk(); return; }
-    if((e.metaKey||e.ctrlKey)&&e.key.toLowerCase()==="e"){ e.preventDefault(); flash("Exported "+P().stems.filter(s=>!s.removed).length+" stems → MIDI"); return; }
+    if((e.metaKey||e.ctrlKey)&&e.key.toLowerCase()==="e"){ e.preventDefault(); if(P()) flash("Exported "+P().stems.filter(s=>!s.removed).length+" stems → MIDI"); return; }
     if((e.metaKey||e.ctrlKey)&&e.key.toLowerCase()==="l"){ e.preventDefault(); $("#omni-input").focus(); $("#omni-input").select(); return; }
-    if(e.key==="Escape"){ closeCmdk(); hideCtx(); }
+    if(e.key==="Escape"){ closeCmdk(); hideCtx(); if(STATE.focusStem) closeFocusTrack(); }
     if(e.target.tagName==="INPUT")return;
     if(e.code==="Space"){ e.preventDefault(); setPlaying(!STATE.playing); }
     if(e.key==="m"&&STATE.sel) toggleMute(STATE.sel);
@@ -769,7 +1082,7 @@ function bind(){
     if(e.key==="+"||e.key==="="){ STATE.zoom=Math.min(2,STATE.zoom+0.1); applyZoom(); }
     if(e.key==="-"){ STATE.zoom=Math.max(0.6,STATE.zoom-0.1); applyZoom(); }
     // arrow select stem
-    if(e.key==="ArrowDown"||e.key==="ArrowUp"){ const st=P().stems; let i=st.findIndex(s=>s.id===STATE.sel); i=(i+(e.key==="ArrowDown"?1:-1)+st.length)%st.length; selectStem(st[i].id); }
+    if(e.key==="ArrowDown"||e.key==="ArrowUp"){ if(!P()) return; const st=P().stems; let i=st.findIndex(s=>s.id===STATE.sel); i=(i+(e.key==="ArrowDown"?1:-1)+st.length)%st.length; selectStem(st[i].id); }
   });
   // hover hints on transport
   document.addEventListener("mouseover",e=>{ const h=e.target.closest("[title]"); });
@@ -780,12 +1093,263 @@ function handleCtxAct(act){
   else if(act.startsWith("pj:")) loadProject(act.slice(3));
   else if(act.startsWith("solo:")) toggleSolo(act.slice(5));
   else if(act.startsWith("mute:")) toggleMute(act.slice(5));
+  else if(act==="flash:proj-export"){
+    const p=P(); if(!p) return;
+    const activeSt=p.stems.filter(s=>!s.removed&&s.midi_url);
+    if(activeSt.length){ activeSt.forEach((s,i)=>setTimeout(()=>{const a=document.createElement("a");a.href=s.midi_url;a.download=s.id+".mid";document.body.appendChild(a);a.click();document.body.removeChild(a);},i*250)); flash("Downloading "+activeSt.length+" MIDI files…"); }
+    else flash("No MIDI data yet — analyze first");
+  }
+  else if(act==="flash:proj-export-wav"){
+    const p=P(); if(!p) return;
+    const activeSt=p.stems.filter(s=>!s.removed&&s.audio_url);
+    if(activeSt.length){ activeSt.forEach((s,i)=>setTimeout(()=>{const a=document.createElement("a");a.href=s.audio_url;a.download=s.id+".wav";document.body.appendChild(a);a.click();document.body.removeChild(a);},i*250)); flash("Downloading "+activeSt.length+" stems…"); }
+    else flash("No stem audio yet");
+  }
+  else if(act==="proj:log"){
+    const sid=STATE.liveSid; if(!sid){flash("No active session");return;}
+    fetch(_api(`/api/detection_log/${sid}`)).then(r=>r.ok?r.text():Promise.reject()).then(txt=>{
+      const w=window.open("","_blank","width=600,height=500");
+      w.document.write(`<pre style="font:13px/1.6 monospace;background:#0a0a0c;color:#ccc;padding:16px;margin:0">${txt.replace(/</g,"&lt;")}</pre>`);
+    }).catch(()=>flash("Detection log not found"));
+  }
+  else if(act==="proj:reanalyze"){
+    if(STATE.url) submitUrl(STATE.url, true);
+    else flash("No URL — drop a file to re-analyze");
+  }
+  else if(act==="proj:close"){
+    setPlaying(false);
+    STATE.liveProject=null; STATE.liveSid=null; STATE.pkey=null;
+    try{ localStorage.removeItem(_LS_SESSION); }catch(_){}
+    setScene("empty");
+  }
   else if(act.startsWith("flash:")) flash(act.slice(6));
+  else if(act.startsWith("ri:")){
+    const [,op,idxStr] = act.split(":");
+    const idx = parseInt(idxStr);
+    const list = _recentSessions();
+    const entry = list[idx];
+    if(!entry) return;
+    if(op==="open"){
+      _openRecentSession(entry);
+    } else if(op==="delete"){
+      list.splice(idx, 1);
+      try{ localStorage.setItem(_LS_RECENT, JSON.stringify(list)); }catch(_){}
+      _renderOpenerRecent();
+      flash("Removed from recents");
+    } else if(op==="dupe"){
+      const copy = { ...entry, title: entry.title + " (copy)" };
+      list.splice(idx + 1, 0, copy);
+      try{ localStorage.setItem(_LS_RECENT, JSON.stringify(list)); }catch(_){}
+      _renderOpenerRecent();
+      flash("Duplicated project entry");
+    } else if(op==="export"){
+      // Re-open the project and go straight to export
+      const sid_raw = localStorage.getItem(_LS_SESSION);
+      if(sid_raw){
+        try{
+          const { sid, project } = JSON.parse(sid_raw);
+          if(sid && project){
+            const activeSt = (project.stems||[]).filter(s=>!s.removed&&s.midi_url);
+            if(activeSt.length){
+              activeSt.forEach((s,i)=>setTimeout(()=>{
+                const a=document.createElement("a"); a.href=s.midi_url; a.download=s.id+".mid";
+                document.body.appendChild(a); a.click(); document.body.removeChild(a);
+              }, i*250));
+              flash("Downloading "+activeSt.length+" MIDI files…");
+              return;
+            }
+          }
+        }catch(_){}
+      }
+      // Fallback: load the project then export
+      document.getElementById("po-url").value = entry.url;
+      _openerGo();
+      flash("Open the project first, then use Export");
+    }
+  }
+}
+// Light redraw: only update opacity + selection classes, no SVG rebuild
+function _lightRedrawScore() {
+  const p=P(); if(!p) return;
+  const solo=STATE.solo.size>0;
+  $$('#score-systems .staff-row').forEach(row=>{
+    const s=p.stems.find(x=>x.id===row.dataset.stem); if(!s) return;
+    const dim=s.removed||STATE.muted.has(s.id)||(solo&&!STATE.solo.has(s.id));
+    row.style.opacity=dim?.34:1;
+    row.classList.toggle('sel',s.id===STATE.sel);
+  });
+}
+
+// Light redraw: update waveform muted tint + M/S button states, no DOM rebuild
+function _lightRedrawTimeline() {
+  const p=P(); if(!p) return;
+  const beats=p.timeSig[0], bpx=STATE.barPx, tb=totalBars();
+  const W=tb*bpx, laneH=46, solo=STATE.solo.size>0;
+  $$('#lanes .lane').forEach(lane=>{
+    const s=p.stems.find(x=>x.id===lane.dataset.stem); if(!s) return;
+    const cv=lane.querySelector('canvas'); if(!cv) return;
+    if(STATE.showWave){
+      const peaks=AudioEngine.hasStem(s.id)?AudioEngine.getPeaks(s.id):null;
+      drawWaveform(cv,{...s,muted:STATE.muted.has(s.id)||(solo&&!STATE.solo.has(s.id))},{width:W,height:laneH,beatPx:bpx/beats,peaks});
+    }
+  });
+  $$('.gutter-track').forEach(gt=>{
+    const id=gt.dataset.stem;
+    gt.querySelector('[data-mute]')?.classList.toggle('on',STATE.muted.has(id));
+    gt.querySelector('[data-solo]')?.classList.toggle('on',STATE.solo.has(id));
+    gt.style.background=id===STATE.sel?'var(--bg-3)':'';
+  });
+}
+
+function toggleMute(id){
+  STATE.muted.has(id)?STATE.muted.delete(id):STATE.muted.add(id);
+  if(STATE.playMode==="midi"){
+    MidiEngine.setMute(id, STATE.muted.has(id));
+    if(STATE.playing){ MidiEngine.stop(); MidiEngine.start(barsToSecs(STATE.pos)); }
+  } else {
+    AudioEngine.setMute(id, STATE.muted.has(id));
+  }
+  _lightRedrawScore(); _lightRedrawTimeline(); selectStem(STATE.sel);
+}
+function toggleSolo(id){
+  STATE.solo.has(id)?STATE.solo.delete(id):STATE.solo.add(id);
+  if(STATE.playMode==="midi"){
+    MidiEngine.setSolo([...STATE.solo]);
+    if(STATE.playing){ MidiEngine.stop(); MidiEngine.start(barsToSecs(STATE.pos)); }
+  } else {
+    AudioEngine.setSolo([...STATE.solo]);
+  }
+  _lightRedrawScore(); _lightRedrawTimeline();
+}
+
+/* ---------------- PROJECT OPENER ────────────────────── */
+const _LS_RECENT = "aegis_recent_v1";
+
+function _recentSessions() {
+  try { return JSON.parse(localStorage.getItem(_LS_RECENT) || "[]"); } catch(_){ return []; }
+}
+function _pushRecent(entry) {
+  const list = _recentSessions().filter(x => x.url !== entry.url).slice(0, 9);
+  list.unshift(entry);
+  try { localStorage.setItem(_LS_RECENT, JSON.stringify(list)); } catch(_){}
+}
+
+function _renderOpenerRecent() {
+  const list = _recentSessions();
+  const el = document.getElementById("po-recent-list");
+  if (!el) return;
+  if (!list.length) { el.innerHTML = '<div class="po-no-recent">No recent sessions yet.</div>'; return; }
+  el.innerHTML = list.map((s, i) => `
+    <div class="po-recent-item" data-po-recent="${i}">
+      <div class="po-ri-thumb" style="background:${s.thumb||'var(--bg-3)'}"></div>
+      <div style="flex:1;min-width:0">
+        <div class="po-ri-title">${s.title||'Untitled'}</div>
+        <div class="po-ri-sub">${s.artist||''} · ${s.url||''}</div>
+      </div>
+      <button class="po-ri-more" data-po-more="${i}" title="More options">⋯</button>
+    </div>`).join("");
+}
+
+function _bindOpener() {
+  // nav tabs
+  document.querySelectorAll(".po-navitem").forEach(btn => {
+    btn.addEventListener("click", () => {
+      document.querySelectorAll(".po-navitem").forEach(b => b.classList.remove("active"));
+      btn.classList.add("active");
+      const tab = btn.dataset.po;
+      document.querySelectorAll(".po-panel").forEach(p => p.classList.remove("active"));
+      document.getElementById("po-panel-" + tab)?.classList.add("active");
+      if (tab === "recent") _renderOpenerRecent();
+    });
+  });
+
+  // URL input enter
+  const urlInp = document.getElementById("po-url");
+  urlInp?.addEventListener("keydown", e => {
+    if (e.key === "Enter") _openerGo();
+  });
+
+  // Go button
+  document.getElementById("po-go-btn")?.addEventListener("click", _openerGo);
+
+  // Drop zone inside opener
+  const dz = document.getElementById("po-drop-zone");
+  if (dz) {
+    dz.addEventListener("click", e => {
+      if (!e.target.classList.contains("po-browse-btn")) document.getElementById("file-picker").click();
+    });
+    dz.addEventListener("dragover", e => { e.preventDefault(); dz.classList.add("drag-over"); });
+    dz.addEventListener("dragleave", () => dz.classList.remove("drag-over"));
+    dz.addEventListener("drop", e => {
+      e.preventDefault(); dz.classList.remove("drag-over");
+      const f = e.dataTransfer.files?.[0];
+      if (f) submitLocalFile(f);
+    });
+  }
+
+  // recent list: click item = open directly; click ⋯ button = ctx menu
+  document.getElementById("po-recent-list")?.addEventListener("click", e => {
+    // ⋯ more button
+    const more = e.target.closest("[data-po-more]");
+    if (more) {
+      e.stopPropagation();
+      const idx = +more.dataset.poMore;
+      const entry = _recentSessions()[idx];
+      if (!entry) return;
+      const r = more.getBoundingClientRect();
+      showCtx(Math.max(0, r.right - 210), r.bottom + 4, [
+        { label: entry.title || "Project" },
+        { t:"Export MIDI", ic:'<path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3"/>',               act:`ri:export:${idx}` },
+        { t:"Duplicate",   ic:'<rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>', act:`ri:dupe:${idx}` },
+        { sep:true },
+        { t:"Remove from list", ic:'<path d="M4 7h16M9 7V4h6v3M6 7l1 13h10l1-13"/>', danger:1, act:`ri:delete:${idx}` },
+      ]);
+      return;
+    }
+    // click anywhere on item = open immediately
+    const item = e.target.closest("[data-po-recent]");
+    if (!item) return;
+    const idx = +item.dataset.poRecent;
+    const entry = _recentSessions()[idx];
+    if (!entry) return;
+    _openRecentSession(entry);
+  });
+}
+
+function _openerGo() {
+  const val = (document.getElementById("po-url")?.value || "").trim();
+  if (val) submitUrl(val);
 }
-function toggleMute(id){ STATE.muted.has(id)?STATE.muted.delete(id):STATE.muted.add(id); AudioEngine.setMute(id, STATE.muted.has(id)); renderScore(); renderTimeline(); selectStem(STATE.sel); }
-function toggleSolo(id){ STATE.solo.has(id)?STATE.solo.delete(id):STATE.solo.add(id); AudioEngine.setSolo([...STATE.solo]); renderScore(); renderTimeline(); }
 
 /* ---------------- INIT ---------------- */
-function boot(){ bind(); loadProject("band","success"); }
+function boot(){
+  bind();
+  _bindOpener();
+  setScene("empty");
+  // Show recent sessions tab by default if any exist
+  if(_recentSessions().length){
+    document.querySelector('.po-navitem[data-po="recent"]')?.click();
+  }
+  // Recompute visible bars on window resize
+  window.addEventListener("resize", ()=>{
+    const p=P(); if(!p) return;
+    p.bars=_calcBars();
+    _invalidateStaffCache(); renderScore();
+  });
+  // WAV / MIDI mode toggle
+  document.getElementById("tp-mode")?.addEventListener("click", ()=>{
+    if(STATE.playing) setPlaying(false);
+    STATE.playMode = STATE.playMode==="midi" ? "wav" : "midi";
+    const btn = document.getElementById("tp-mode");
+    const isMidi = STATE.playMode==="midi";
+    btn.textContent = isMidi ? "MIDI" : "WAV";
+    btn.classList.toggle("on", isMidi);
+    if(isMidi){ const p=P(); if(p) MidiEngine.load(p.stems); }
+    flash(isMidi ? "MIDI synth mode — plays note synthesis" : "WAV mode — plays separated stems");
+  });
+  // Auto-save on app close / page unload
+  window.addEventListener("beforeunload", _saveSession);
+}
+
 document.fonts && document.fonts.ready.then(()=>{ renderScore(); });
 boot();
diff --git a/js/data.js b/js/data.js
index c16ef99..e47c155 100644
--- a/js/data.js
+++ b/js/data.js
@@ -5,123 +5,25 @@
 const DIA = { C:0, D:1, E:2, F:3, G:4, A:5, B:6 };
 function dabs(step, oct){ return oct*7 + DIA[step]; }
 
-// key signatures -> which diatonic steps are sharp/flat (for accidental glyphs)
-const KEYSIG = {
-  "F# minor": { sharps:["F","C","G"], flats:[] },
-  "D major":  { sharps:["F","C"], flats:[] },
-  "A minor":  { sharps:[], flats:[] },
-  "Bb major": { sharps:[], flats:["B","E"] },
+// key signatures — generated from circle of fifths, covers all 30 standard keys
+// Sharp order (FCGDAEB) and flat order (BEADGCF) are music-theory constants
+const _SHARP_ORDER = ['F','C','G','D','A','E','B'];
+const _FLAT_ORDER  = ['B','E','A','D','G','C','F'];
+const _FIFTHS = {
+  // major keys
+  'C major':0,'G major':1,'D major':2,'A major':3,'E major':4,'B major':5,
+  'F# major':6,'C# major':7,
+  'F major':-1,'Bb major':-2,'Eb major':-3,'Ab major':-4,'Db major':-5,'Gb major':-6,'Cb major':-7,
+  // minor keys (same accidentals as relative major)
+  'A minor':0,'E minor':1,'B minor':2,'F# minor':3,'C# minor':4,'G# minor':5,
+  'D# minor':6,'A# minor':7,
+  'D minor':-1,'G minor':-2,'C minor':-3,'F minor':-4,'Bb minor':-5,'Eb minor':-6,'Ab minor':-7,
 };
+const KEYSIG = {};
+Object.entries(_FIFTHS).forEach(([key, n]) => {
+  KEYSIG[key] = n > 0
+    ? { sharps: _SHARP_ORDER.slice(0, n), flats: [] }
+    : { sharps: [], flats: _FLAT_ORDER.slice(0, -n) };
+});
 
-const PROJECTS = {
-
-  /* ---------------- HERO: band track ---------------- */
-  band: {
-    id:"band", kind:"band",
-    title:"Midnight Cartography",
-    artist:"Neon Tide",
-    album:"Atlas of Sleep · 2025",
-    source:"youtube.com/watch?v=k7Qm2x9LpZ4",
-    thumb:"linear-gradient(135deg, oklch(0.5 0.16 290), oklch(0.45 0.14 245) 60%, oklch(0.55 0.13 30))",
-    duration:218.4, tempo:122, tempoMap:[[0,122],[64,122],[112,118],[160,122]],
-    key:"F# minor", timeSig:[4,4], sampleRate:48000, bitDepth:24,
-    sepModel:"HT-Demucs v4 · 6-stem", transModel:"OvertoneNet-MIDI 2.3",
-    gpu:{ model:"RTX 4090", util:14, vram:6.2, vramTotal:24 },
-    bars:8, barOffset:33,
-    stems:[
-      { id:"drums", name:"Drums", instrument:"Acoustic Kit", family:"Percussion · GM 0",
-        clef:"perc", color:"--s-drums", confidence:99.1, midi:412, role:"Rhythm",
-        quality:{ snr:31.4, bleed:2.1, artifacts:0.8, separation:98.7 },
-        density:4, seed:11, note:"Tight pocket · ghost notes on snare" },
-      { id:"bass", name:"Bass", instrument:"Electric Bass (finger)", family:"Bass · GM 33",
-        clef:"bass", color:"--s-bass", confidence:97.4, midi:96, role:"Low end",
-        reg:[dabs("E",1),dabs("D",3)], density:2, seed:7, note:"Root–fifth, syncopated" },
-      { id:"guitar", name:"Elec. Guitar", instrument:"Clean Strat", family:"Guitar · GM 27",
-        clef:"treble", color:"--s-guitar", confidence:91.2, midi:188, role:"Harmony",
-        reg:[dabs("G",3),dabs("E",5)], density:3, seed:23, note:"Arpeggiated, light chorus" },
-      { id:"synth", name:"Lead Synth", instrument:"Analog Saw Lead", family:"Synth Lead · GM 81",
-        clef:"treble", color:"--s-synth", confidence:93.0, midi:142, role:"Melody",
-        reg:[dabs("D",4),dabs("A",5)], density:3, seed:41, note:"Detuned, portamento" },
-      { id:"keys", name:"Keys / Pad", instrument:"Warm Poly Pad", family:"Synth Pad · GM 89",
-        clef:"treble", color:"--s-keys", confidence:88.6, midi:74, role:"Texture",
-        reg:[dabs("F",3),dabs("C",5)], density:1, seed:5, note:"Sustained triads, slow swell" },
-      { id:"vocal", name:"Vocals", instrument:"Lead Vocal", family:"Voice", removed:true,
-        clef:"treble", color:"--s-vocal", confidence:95.7, midi:0, role:"Removed",
-        reg:[dabs("A",3),dabs("E",5)], density:2, seed:13, note:"Isolated & muted by request" },
-    ],
-    diagnostics:[
-      { sev:"ok",   t:"Vocal isolation clean", s:"No residual lead vocal in instrumental sum.", v:"−42 dB" },
-      { sev:"warn", t:"Guitar/keys spectral overlap", s:"Bands 2–4 kHz contend; minor bleed on bar 47.", v:"6.8%" },
-      { sev:"ok",   t:"Transient preservation high", s:"Drum attacks retained through separation.", v:"98.7%" },
-      { sev:"info", t:"Tempo drift detected", s:"Ritardando across bars 28–30, mapped automatically.", v:"−4 BPM" },
-      { sev:"ok",   t:"MIDI quantize confidence", s:"Onset grid locked to 1/16 at 122 BPM.", v:"96.1%" },
-    ],
-    spectrum:[8,17,28,42,61,73,68,55,47,52,44,38,31,36,27,22,18,24,15,11,14,9,7,12,6,5,8,4,3,5,2,3],
-  },
-
-  /* ---------------- MASSIVE: orchestral ---------------- */
-  orchestra: {
-    id:"orchestra", kind:"orchestra",
-    title:"Aurora Borealis Suite — Mvt. II",
-    artist:"E. Halvorsen · Oslo Phil.",
-    album:"Northern Lights · Live 2024",
-    source:"youtube.com/watch?v=A3v8Nq1RtY0",
-    thumb:"linear-gradient(135deg, oklch(0.5 0.13 200), oklch(0.55 0.13 150) 55%, oklch(0.6 0.12 80))",
-    duration:512.0, tempo:88, tempoMap:[[0,72],[40,88],[300,96],[440,80]],
-    key:"D major", timeSig:[3,4], sampleRate:96000, bitDepth:24,
-    sepModel:"OrchSep-XL · 14-source", transModel:"OvertoneNet-MIDI 2.3 · poly",
-    gpu:{ model:"RTX 4090", util:71, vram:18.9, vramTotal:24 },
-    bars:6, barOffset:51,
-    stems:[
-      { id:"vln1", name:"Violin I", instrument:"Strings", family:"Strings · divisi a2", clef:"treble", color:"--s-strings", confidence:84.2, midi:266, reg:[dabs("G",4),dabs("E",6)], density:4, seed:3, note:"Soaring theme, legato" },
-      { id:"vln2", name:"Violin II", instrument:"Strings", family:"Strings", clef:"treble", color:"--s-strings", confidence:81.5, midi:240, reg:[dabs("D",4),dabs("B",5)], density:3, seed:9, note:"Inner harmony" },
-      { id:"vla", name:"Viola", instrument:"Strings", family:"Strings", clef:"alto", color:"--s-strings", confidence:78.9, midi:198, reg:[dabs("C",3),dabs("E",5)], density:3, seed:14, note:"Counter-melody" },
-      { id:"vc", name:"Cello", instrument:"Strings", family:"Strings", clef:"bass", color:"--s-strings", confidence:86.1, midi:176, reg:[dabs("C",2),dabs("A",3)], density:2, seed:6, note:"Pedal + arco swells" },
-      { id:"cb", name:"Contrabass", instrument:"Strings", family:"Strings · 8vb", clef:"bass", color:"--s-strings", confidence:88.4, midi:88, reg:[dabs("E",1),dabs("D",3)], density:1, seed:2, note:"Foundation" },
-      { id:"fl", name:"Flute", instrument:"Woodwind", family:"Woodwind · a2", clef:"treble", color:"--s-wood", confidence:79.2, midi:154, reg:[dabs("D",5),dabs("C",7)], density:4, seed:21, note:"Doubling Vln I 8va" },
-      { id:"ob", name:"Oboe", instrument:"Woodwind", family:"Woodwind", clef:"treble", color:"--s-wood", confidence:72.6, midi:120, reg:[dabs("B",4),dabs("F",6)], density:2, seed:33, note:"Plaintive solo, bars 12–18" },
-      { id:"cl", name:"Clarinet", instrument:"Woodwind", family:"Woodwind · in Bb", clef:"treble", color:"--s-wood", confidence:74.8, midi:138, reg:[dabs("E",3),dabs("C",6)], density:3, seed:28, note:"Arpeggiated figures" },
-      { id:"bsn", name:"Bassoon", instrument:"Woodwind", family:"Woodwind", clef:"bass", color:"--s-wood", confidence:76.0, midi:104, reg:[dabs("B",1),dabs("E",4)], density:2, seed:18, note:"Tenor line" },
-      { id:"hn", name:"Horns", instrument:"Brass", family:"Brass · F, a4", clef:"treble", color:"--s-brass", confidence:69.3, midi:96, reg:[dabs("C",3),dabs("G",4)], density:1, seed:44, note:"Sustained pads, low conf." },
-      { id:"tpt", name:"Trumpets", instrument:"Brass", family:"Brass · C, a2", clef:"treble", color:"--s-brass", confidence:71.1, midi:78, reg:[dabs("G",3),dabs("D",5)], density:1, seed:37, note:"Fanfare, bar 22" },
-      { id:"tbn", name:"Trombones", instrument:"Brass", family:"Brass · a3", clef:"bass", color:"--s-brass", confidence:73.5, midi:64, reg:[dabs("E",2),dabs("C",4)], density:1, seed:12, note:"Chorale" },
-      { id:"timp", name:"Timpani", instrument:"Percussion", family:"Perc · D–A", clef:"bass", color:"--s-perc", confidence:90.7, midi:42, reg:[dabs("D",2),dabs("A",2)], density:1, seed:8, note:"Rolls + accents" },
-      { id:"harp", name:"Harp", instrument:"Plucked", family:"Plucked · pedal D", clef:"treble", color:"--s-keys", confidence:80.4, midi:212, reg:[dabs("C",3),dabs("F",6)], density:4, seed:50, note:"Glissandi, arpeggios" },
-    ],
-    diagnostics:[
-      { sev:"warn", t:"Brass separation degraded", s:"Horn/trombone overlap in 200–500 Hz; 14-source limit.", v:"69.3%" },
-      { sev:"warn", t:"Divisi strings under-resolved", s:"Vln I a2 collapsed to single source above 4 kHz.", v:"a2→1" },
-      { sev:"ok",   t:"Timpani transients isolated", s:"Pitched percussion cleanly extracted.", v:"90.7%" },
-      { sev:"info", t:"96 kHz source", s:"High-res input improved upper-partial recovery.", v:"96 kHz" },
-      { sev:"err",  t:"Oboe solo masked", s:"Bars 14–16 below detection floor under tutti.", v:"−38 dB" },
-      { sev:"info", t:"Reverb tail (hall)", s:"RT60 ≈ 2.4 s folded into wet residual stem.", v:"2.4 s" },
-    ],
-    spectrum:[14,26,41,58,72,79,74,68,71,64,58,61,53,48,55,44,49,38,42,33,37,29,31,24,27,19,22,15,12,9,7,5],
-  },
-
-  /* ---------------- SMALL: solo piano ---------------- */
-  piano: {
-    id:"piano", kind:"piano",
-    title:"Gymnopédie No. 1",
-    artist:"Erik Satie",
-    album:"Trois Gymnopédies · 1888 · Public Domain",
-    source:"youtube.com/watch?v=S-Xm7s9d0kE",
-    thumb:"linear-gradient(135deg, oklch(0.5 0.06 80), oklch(0.45 0.05 60) 60%, oklch(0.4 0.04 40))",
-    duration:198.0, tempo:70, tempoMap:[[0,70]],
-    key:"D major", timeSig:[3,4], sampleRate:44100, bitDepth:16,
-    sepModel:"Solo bypass · no separation", transModel:"OvertoneNet-MIDI 2.3 · piano",
-    gpu:{ model:"RTX 4090", util:4, vram:1.8, vramTotal:24 },
-    bars:6, barOffset:5, grand:true,
-    stems:[
-      { id:"pno_r", name:"Piano — R.H.", instrument:"Grand Piano", family:"Keyboard · GM 0", clef:"treble", color:"--s-keys", confidence:99.6, midi:96, reg:[dabs("F",4),dabs("A",5)], density:1, seed:1, note:"Lent et douloureux — melody" },
-      { id:"pno_l", name:"Piano — L.H.", instrument:"Grand Piano", family:"Keyboard · GM 0", clef:"bass", color:"--s-keys", confidence:99.4, midi:148, reg:[dabs("D",2),dabs("B",3)], density:2, seed:4, note:"Bass note + chord, ¾ accompaniment" },
-    ],
-    diagnostics:[
-      { sev:"ok",   t:"Single-source — direct transcription", s:"No separation needed; raw-to-MIDI path used.", v:"100%" },
-      { sev:"ok",   t:"Pedal events recovered", s:"Sustain (CC64) inferred from decay envelopes.", v:"24 events" },
-      { sev:"ok",   t:"Voicing detected", s:"3-voice polyphony tracked across both hands.", v:"3 voices" },
-      { sev:"info", t:"Dynamics: pp–mp", s:"Velocity range compressed; gentle reading.", v:"18–54" },
-    ],
-    spectrum:[6,12,22,34,28,20,15,18,11,9,13,7,6,10,5,4,7,3,5,2,4,2,3,1,2,1,2,1,1,1,1,1],
-  },
-};
+const PROJECTS = {};
diff --git a/js/export.js b/js/export.js
new file mode 100644
index 0000000..45ae495
--- /dev/null
+++ b/js/export.js
@@ -0,0 +1,484 @@
+/* ============================================================
+   export.js — MusicXML / MuseScore (.mscz) / PDF score export + File menu
+   ============================================================ */
+
+function toggleFileMenu(e) {
+  e && e.stopPropagation();
+  const dd = document.getElementById('dd-file');
+  const open = dd.classList.toggle('open');
+  if (open) _populateExportStemSel();
+}
+
+document.addEventListener('click', () => {
+  document.getElementById('dd-file')?.classList.remove('open');
+});
+
+function _populateExportStemSel() {
+  const p = typeof P === 'function' ? P() : null;
+  const sel = document.getElementById('exp-stem-sel');
+  if (!sel) return;
+  sel.innerHTML = '';
+  if (!p) { sel.innerHTML = '<option value="">No project</option>'; return; }
+  // Drums have no pitched MIDI (pyin can't transcribe percussion) — skip them
+  const exportable = p.stems.filter(s => s.id !== 'drums' && s.name.toLowerCase() !== 'drums');
+  if (!exportable.length) { sel.innerHTML = '<option value="">No pitched tracks</option>'; return; }
+  exportable.forEach(s => {
+    const o = document.createElement('option');
+    o.value = s.id;
+    o.textContent = s.name;
+    sel.appendChild(o);
+  });
+  if (typeof STATE !== 'undefined' && STATE.sel && STATE.sel !== 'drums') sel.value = STATE.sel;
+}
+
+// ── Key sig fifths table ──────────────────────────────────────────────────────
+const _KEY_5THS = {
+  'C major':0,'G major':1,'D major':2,'A major':3,'E major':4,'B major':5,
+  'F# major':6,'C# major':7,'F major':-1,'Bb major':-2,'Eb major':-3,
+  'Ab major':-4,'Db major':-5,'Gb major':-6,'Cb major':-7,
+  'A minor':0,'E minor':1,'B minor':2,'F# minor':3,'C# minor':4,'G# minor':5,
+  'D# minor':6,'A# minor':7,'D minor':-1,'G minor':-2,'C minor':-3,
+  'F minor':-4,'Bb minor':-5,'Eb minor':-6,'Ab minor':-7,
+};
+
+function _escXml(s) {
+  return String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+
+// ── MusicXML 3.1 builder ──────────────────────────────────────────────────────
+function _buildMusicXML(stem, project) {
+  const tempo = project.tempo || 120;
+  const [beatsPerBar, beatUnit] = project.timeSig || [4, 4];
+  const secPerBeat = 60 / tempo;
+  const barSecs = beatsPerBar * secPerBeat;
+  const DIVS = 480;
+
+  const _STEPS = ['C','C','D','D','E','F','F','G','G','A','A','B'];
+  const _ALTER = [0,  1,  0,  1,  0,  0,  1,  0,  1,  0,  1,  0];
+
+  function _pitch(midi) {
+    const pc = ((midi % 12) + 12) % 12;
+    return { step: _STEPS[pc], alter: _ALTER[pc], oct: Math.floor(midi / 12) - 1 };
+  }
+
+  function qz(secs) { return Math.round(secs / secPerBeat / 0.25) * 0.25; } // snap to 16th-beat grid
+
+  const notes = [...(stem.midiNotes || [])].sort((a, b) => a.start - b.start);
+  const last = notes[notes.length - 1];
+  const totalBarsXml = last ? Math.ceil(last.end / barSecs) + 1 : 1;
+  const fifths = _KEY_5THS[project.key] ?? 0;
+  const mode   = (project.key || '').includes('minor') ? 'minor' : 'major';
+  const clefSign = stem.clef === 'bass' ? 'F' : 'G';
+  const clefLine = stem.clef === 'bass' ? 4 : 2;
+
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>\n` +
+    `<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 3.1 Partwise//EN" ` +
+    `"http://www.musicxml.org/dtds/partwise.dtd">\n` +
+    `<score-partwise version="3.1">\n` +
+    `  <work><work-title>${_escXml(project.title)}</work-title></work>\n` +
+    `  <identification><encoding><software>AegisScore</software>` +
+    `<encoding-date>${new Date().toISOString().slice(0,10)}</encoding-date></encoding></identification>\n` +
+    `  <part-list><score-part id="P1"><part-name>${_escXml(stem.name)}</part-name>` +
+    `<score-instrument id="P1-I1"><instrument-name>${_escXml(stem.instrument || stem.name)}</instrument-name>` +
+    `</score-instrument></score-part></part-list>\n  <part id="P1">`;
+
+  for (let bar = 0; bar < totalBarsXml; bar++) {
+    const t0 = bar * barSecs, t1 = t0 + barSecs;
+    const bn = notes.filter(n => n.start < t1 && n.end > t0);
+
+    xml += `\n    <measure number="${bar + 1}">`;
+    if (bar === 0) {
+      xml += `\n      <attributes>` +
+        `<divisions>${DIVS}</divisions>` +
+        `<key><fifths>${fifths}</fifths><mode>${mode}</mode></key>` +
+        `<time><beats>${beatsPerBar}</beats><beat-type>${beatUnit}</beat-type></time>` +
+        `<clef><sign>${clefSign}</sign><line>${clefLine}</line></clef></attributes>`;
+      xml += `\n      <direction placement="above">` +
+        `<direction-type><metronome><beat-unit>quarter</beat-unit>` +
+        `<per-minute>${tempo}</per-minute></metronome></direction-type>` +
+        `<sound tempo="${tempo}"/></direction>`;
+    }
+
+    if (bn.length === 0) {
+      xml += `\n      <note><rest measure="yes"/><duration>${DIVS * beatsPerBar}</duration><type>whole</type></note>`;
+    } else {
+      // Group simultaneous notes into chords (within one 16th of each other)
+      const evts = bn.map(n => ({
+        startB: Math.max(0, Math.min(qz(n.start - t0), beatsPerBar - 0.25)),
+        endB:   Math.min(beatsPerBar, Math.max(qz(n.end - t0), 0.25)),
+        pitch:  n.pitch,
+      })).filter(e => e.endB > e.startB).sort((a, b) => a.startB - b.startB);
+
+      const chords = [];
+      for (const e of evts) {
+        const prev = chords[chords.length - 1];
+        if (prev && e.startB < prev.startB + 0.125) {
+          prev.pitches.push(e.pitch);
+          prev.endB = Math.max(prev.endB, e.endB);
+        } else {
+          if (prev && prev.endB > e.startB) prev.endB = e.startB;
+          chords.push({ startB: e.startB, endB: e.endB, pitches: [e.pitch] });
+        }
+      }
+      chords.forEach(c => {
+        const uniq = [...new Set(c.pitches)];
+        c.pitches = stem.clef === 'bass' ? [Math.min(...uniq)] : uniq.slice(0, 4);
+      });
+
+      let pos = 0;
+      for (const c of chords) {
+        if (c.startB > pos + 0.124) {
+          const sn = _snapNote(c.startB - pos, beatsPerBar - pos);
+          const d = Math.round(sn.b * DIVS);
+          xml += `\n      <note><rest/><duration>${d}</duration>` +
+            (sn.dots ? `<dot/>` : '') + `<type>${sn.t}</type></note>`;
+          pos = Math.round((pos + sn.b) * 1000) / 1000;
+        }
+        pos = c.startB;
+        const durB = Math.max(0.25, Math.min(c.endB - c.startB, beatsPerBar - pos));
+        const sn   = _snapNote(durB, beatsPerBar - pos);
+        const nd   = Math.round(sn.b * DIVS);
+        const firstPitch = c.pitches[0];
+        const pp = _pitch(firstPitch);
+        // First note in chord (no <chord/> tag)
+        xml += `\n      <note><pitch><step>${pp.step}</step>` +
+          (pp.alter ? `<alter>${pp.alter}</alter>` : '') +
+          `<octave>${pp.oct}</octave></pitch>` +
+          `<duration>${nd}</duration><voice>1</voice>` +
+          (sn.dots ? `<dot/>` : '') + `<type>${sn.t}</type></note>`;
+        // Additional pitches in chord (with <chord/> tag)
+        for (let i = 1; i < c.pitches.length; i++) {
+          const pp2 = _pitch(c.pitches[i]);
+          xml += `\n      <note><chord/><pitch><step>${pp2.step}</step>` +
+            (pp2.alter ? `<alter>${pp2.alter}</alter>` : '') +
+            `<octave>${pp2.oct}</octave></pitch>` +
+            `<duration>${nd}</duration><voice>1</voice>` +
+            (sn.dots ? `<dot/>` : '') + `<type>${sn.t}</type></note>`;
+        }
+        pos = Math.round((pos + sn.b) * 1000) / 1000;
+      }
+
+      if (pos < beatsPerBar - 0.124) {
+        const sn = _snapNote(beatsPerBar - pos, beatsPerBar - pos);
+        const d  = Math.round(sn.b * DIVS);
+        xml += `\n      <note><rest/><duration>${d}</duration>` +
+          (sn.dots ? `<dot/>` : '') + `<type>${sn.t}</type></note>`;
+      }
+    }
+    xml += '\n    </measure>';
+  }
+
+  xml += '\n  </part>\n</score-partwise>';
+  return xml;
+}
+
+// ── MuseScore 3 native format (.mscz = zip containing .mscx) ─────────────────
+
+const _TPC_SHARP = [14, 21, 16, 23, 18, 13, 20, 15, 22, 17, 24, 19];
+const _TPC_FLAT  = [14,  9, 16, 11, 18, 13,  8, 15, 10, 17, 12, 19];
+const _GM_PROG   = { bass: 33, other: 40, vocals: 52, guitar: 25, piano: 0 };
+
+// Valid note durations in beats, largest first
+const _NOTE_VALS = [
+  {b:4,   t:'whole',   dots:0},
+  {b:3,   t:'half',    dots:1},
+  {b:2,   t:'half',    dots:0},
+  {b:1.5, t:'quarter', dots:1},
+  {b:1,   t:'quarter', dots:0},
+  {b:0.75,t:'eighth',  dots:1},
+  {b:0.5, t:'eighth',  dots:0},
+  {b:0.375,t:'16th',   dots:1},
+  {b:0.25,t:'16th',    dots:0},
+  {b:0.125,t:'32nd',   dots:0},
+];
+
+// Snap db beats to nearest valid note value ≤ maxB
+function _snapNote(db, maxB = 8) {
+  db = Math.max(0.125, db);
+  const cands = _NOTE_VALS.filter(v => v.b <= maxB + 0.001);
+  if (!cands.length) return _NOTE_VALS[_NOTE_VALS.length - 1];
+  return cands.reduce((best, v) => Math.abs(v.b - db) < Math.abs(best.b - db) ? v : best);
+}
+
+// Decompose a beat-duration into a sequence of valid note values
+function _decompose(db, maxFirstB = 8) {
+  const parts = [];
+  let rem = Math.max(0, Math.round(db * 1000) / 1000);
+  let first = true;
+  for (let guard = 0; rem >= 0.124 && guard < 24; guard++) {
+    const s = _snapNote(rem, first ? maxFirstB : rem);
+    parts.push(s);
+    rem = Math.round((rem - s.b) * 1000) / 1000;
+    first = false;
+  }
+  return parts;
+}
+
+function _buildMscx(stem, project) {
+  const tempo  = project.tempo || 120;
+  const [sigN, sigD] = project.timeSig || [4, 4];
+  const BPS    = tempo / 60;                     // beats per second
+  const barSecs = sigN / BPS;
+  const GRID   = 0.25;                           // 16th-note quantisation grid (beats)
+  const fifths = _KEY_5THS[project.key] ?? 0;
+  const TPC    = fifths < 0 ? _TPC_FLAT : _TPC_SHARP;
+  const prog   = _GM_PROG[stem.id] ?? 0;
+  const clef   = stem.clef === 'bass' ? 'F' : 'G';
+
+  function qz(beats) { return Math.round(beats / GRID) * GRID; }
+
+  function chordXml(type, dots, pitches) {
+    let s = `          <Chord><durationType>${type}</durationType>`;
+    if (dots) s += `<dots>${dots}</dots>`;
+    pitches.forEach(p => {
+      const pc = ((p % 12) + 12) % 12;
+      s += `<Note><pitch>${p}</pitch><tpc>${TPC[pc]}</tpc></Note>`;
+    });
+    return s + `</Chord>\n`;
+  }
+
+  function restXml(type, dots) {
+    return `          <Rest><durationType>${type}</durationType>${dots ? `<dots>${dots}</dots>` : ''}</Rest>\n`;
+  }
+
+  const allNotes = [...(stem.midiNotes || [])].sort((a, b) => a.start - b.start);
+  const last = allNotes[allNotes.length - 1];
+  const totalMeasures = last ? Math.ceil(last.end / barSecs) + 1 : 1;
+
+  let x  = `<?xml version="1.0" encoding="UTF-8"?>\n<museScore version="3.01">\n  <Score>\n`;
+  x += `    <Division>480</Division>\n    <Style/>\n`;
+  x += `    <metaTag name="title">${_escXml(project.title)}</metaTag>\n`;
+  x += `    <Part>\n      <Staff id="1"/>\n      <trackName>${_escXml(stem.name)}</trackName>\n`;
+  x += `      <Instrument>\n        <trackName>${_escXml(stem.name)}</trackName>\n`;
+  x += `        <Channel><program value="${prog}"/></Channel>\n      </Instrument>\n    </Part>\n`;
+  x += `    <Staff id="1">\n`;
+
+  for (let m = 0; m < totalMeasures; m++) {
+    const t0 = m * barSecs, t1 = t0 + barSecs;
+    const mn = allNotes.filter(n => n.start < t1 && n.end > t0);
+
+    x += `      <Measure>\n        <voice>\n`;
+    if (m === 0) {
+      x += `          <KeySig><accidental>${fifths}</accidental></KeySig>\n`;
+      x += `          <TimeSig><sigN>${sigN}</sigN><sigD>${sigD}</sigD></TimeSig>\n`;
+      x += `          <Clef><subtype>${clef}</subtype></Clef>\n`;
+      x += `          <Tempo><tempo>${(tempo / 60).toFixed(6)}</tempo></Tempo>\n`;
+    }
+
+    if (mn.length === 0) {
+      x += `          <Rest><durationType>measure</durationType><duration>${sigN}/${sigD}</duration></Rest>\n`;
+    } else {
+      // Convert to beat offsets relative to measure start, quantise to grid
+      const evts = mn.map(n => ({
+        startB: Math.max(0, Math.min(qz((n.start - t0) * BPS), sigN - GRID)),
+        endB:   Math.min(sigN, Math.max(qz((n.end   - t0) * BPS), GRID)),
+        pitch:  n.pitch,
+      })).filter(e => e.endB > e.startB);
+
+      evts.sort((a, b) => a.startB - b.startB);
+
+      // Group simultaneous notes (within GRID/2) into chords, clip overlapping ends
+      const chords = [];
+      for (const e of evts) {
+        const prev = chords[chords.length - 1];
+        if (prev && e.startB < prev.startB + GRID / 2) {
+          prev.pitches.push(e.pitch);
+          prev.endB = Math.max(prev.endB, e.endB);
+        } else {
+          if (prev && prev.endB > e.startB) prev.endB = e.startB;
+          chords.push({ startB: e.startB, endB: e.endB, pitches: [e.pitch] });
+        }
+      }
+
+      // Reduce polyphony: bass → lowest pitch only; others → up to 4 unique pitches
+      chords.forEach(c => {
+        const uniq = [...new Set(c.pitches)];
+        c.pitches = stem.clef === 'bass' ? [Math.min(...uniq)] : uniq.slice(0, 4);
+      });
+
+      // Render chords with proper rests filling all gaps
+      let pos = 0;
+      for (const c of chords) {
+        if (c.startB > pos + GRID / 2) {
+          _decompose(c.startB - pos, sigN - pos).forEach(r => { x += restXml(r.t, r.dots); });
+        }
+        pos = c.startB;
+        const durB = Math.max(GRID, Math.min(c.endB - c.startB, sigN - pos));
+        const sn   = _snapNote(durB, sigN - pos);
+        x += chordXml(sn.t, sn.dots, c.pitches);
+        pos += sn.b;
+        pos  = Math.round(pos * 1000) / 1000;
+      }
+
+      // Fill tail of measure with rests
+      if (pos < sigN - GRID / 2) {
+        _decompose(sigN - pos, sigN - pos).forEach(r => { x += restXml(r.t, r.dots); });
+      }
+    }
+
+    x += `        </voice>\n      </Measure>\n`;
+  }
+
+  x += `    </Staff>\n  </Score>\n</museScore>`;
+  return x;
+}
+
+// CRC-32 for ZIP
+function _crc32(u8arr) {
+  let crc = 0xFFFFFFFF;
+  for (let i = 0; i < u8arr.length; i++) {
+    crc ^= u8arr[i];
+    for (let j = 0; j < 8; j++) crc = (crc >>> 1) ^ (crc & 1 ? 0xEDB88320 : 0);
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
+// Pack a single file into a ZIP blob (stored, no compression)
+function _makeMscz(innerFilename, xmlStr) {
+  const enc = new TextEncoder();
+  const nameBytes = enc.encode(innerFilename);
+  const data = enc.encode(xmlStr);
+  const crc = _crc32(data);
+
+  const now = new Date();
+  const dosTime = (now.getHours() << 11) | (now.getMinutes() << 5) | Math.floor(now.getSeconds() / 2);
+  const dosDate = ((now.getFullYear() - 1980) << 9) | ((now.getMonth() + 1) << 5) | now.getDate();
+
+  const LFH = 30 + nameBytes.length;        // local file header size
+  const CDH = 46 + nameBytes.length;        // central directory header size
+  const total = LFH + data.length + CDH + 22;
+
+  const buf = new ArrayBuffer(total);
+  const v = new DataView(buf);
+  const u8 = new Uint8Array(buf);
+  let p = 0;
+
+  const w32 = n => { v.setUint32(p, n, true); p += 4; };
+  const w16 = n => { v.setUint16(p, n, true); p += 2; };
+  const wB  = arr => { u8.set(arr, p); p += arr.length; };
+
+  // Local file header
+  w32(0x04034B50); w16(20); w16(0); w16(0); // sig, ver, flags, method=stored
+  w16(dosTime); w16(dosDate);
+  w32(crc); w32(data.length); w32(data.length);
+  w16(nameBytes.length); w16(0);
+  wB(nameBytes); wB(data);
+
+  const cdOff = p; // start of central directory
+
+  // Central directory header
+  w32(0x02014B50); w16(20); w16(20); w16(0); w16(0);
+  w16(dosTime); w16(dosDate);
+  w32(crc); w32(data.length); w32(data.length);
+  w16(nameBytes.length); w16(0); w16(0); w16(0); w16(0);
+  w32(0); w32(0); // external attrs, local header offset
+  wB(nameBytes);
+
+  const cdSize = p - cdOff;
+
+  // End of central directory
+  w32(0x06054B50); w16(0); w16(0); w16(1); w16(1);
+  w32(cdSize); w32(cdOff); w16(0);
+
+  return new Blob([buf], { type: 'application/octet-stream' });
+}
+
+// ── Download helper ───────────────────────────────────────────────────────────
+function _downloadBlob(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url; a.download = filename;
+  document.body.appendChild(a); a.click();
+  setTimeout(() => { document.body.removeChild(a); URL.revokeObjectURL(url); }, 1000);
+}
+
+// ── Public export entry point ─────────────────────────────────────────────────
+async function exportScore(fmt) {
+  document.getElementById('dd-file')?.classList.remove('open');
+  const p = typeof P === 'function' ? P() : null;
+  if (!p) { alert('No project open.'); return; }
+  const stemId = document.getElementById('exp-stem-sel')?.value || p.stems.find(s => s.id !== 'drums')?.id;
+  const stem = p.stems.find(s => s.id === stemId);
+  if (!stem) return;
+
+  if (stem.id === 'drums' || stem.name.toLowerCase() === 'drums') {
+    alert('Drums track has no pitched MIDI data — choose a different track.'); return;
+  }
+
+  // Lazy-load if midiNotes was never initialized (undefined = never attempted)
+  if (stem.midiNotes === undefined) {
+    const sid = typeof STATE !== 'undefined' ? STATE.liveSid : null;
+    if (sid && stem.midi_url) {
+      try {
+        const r = await fetch(`/api/midi/${sid}/${stem.id}`);
+        if (r.ok) { const d = await r.json(); stem.midiNotes = d.notes || []; }
+        else stem.midiNotes = [];
+      } catch(_) { stem.midiNotes = []; }
+    } else {
+      stem.midiNotes = [];
+    }
+  }
+  // midiNotes is now always defined — [] means no detected notes (export with rests)
+  if (stem.midiNotes === undefined) {
+    alert(`Cannot export "${stem.name}" — process a song first.`); return;
+  }
+
+  if (fmt === 'musicxml') {
+    const xml = _buildMusicXML(stem, p);
+    _downloadBlob(
+      new Blob([xml], { type: 'application/vnd.recordare.musicxml+xml' }),
+      `${p.title} - ${stem.name}.musicxml`
+    );
+
+  } else if (fmt === 'musescore') {
+    const mscx = _buildMscx(stem, p);
+    const safeName = `${p.title} - ${stem.name}`.replace(/[/\\:*?"<>|]/g, '_');
+    const blob = _makeMscz(`${safeName}.mscx`, mscx);
+    _downloadBlob(blob, `${safeName}.mscz`);
+
+  } else if (fmt === 'pdf') {
+    const row = [...document.querySelectorAll('#score-systems .staff-row')]
+      .find(r => r.dataset.stem === stemId);
+    const liveSvg = row?.querySelector('svg');
+
+    let svgStr;
+    if (liveSvg) {
+      const clone = liveSvg.cloneNode(true);
+      const bg = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+      bg.setAttribute('x', 0); bg.setAttribute('y', 0);
+      bg.setAttribute('width', clone.getAttribute('width'));
+      bg.setAttribute('height', clone.getAttribute('height'));
+      bg.setAttribute('fill', '#ffffff');
+      clone.insertBefore(bg, clone.firstChild);
+      svgStr = new XMLSerializer().serializeToString(clone);
+    }
+
+    const stemInfo = `${stem.name} &nbsp;·&nbsp; ${_escXml(p.key)} &nbsp;·&nbsp; ${p.tempo} BPM &nbsp;·&nbsp; ${(p.timeSig || [4,4]).join('/')}`;
+    const barLabel = `Bars ${(p.barOffset || 0) + 1}–${(p.barOffset || 0) + p.bars}`;
+    const imgTag = svgStr
+      ? `<img src="data:image/svg+xml;base64,${btoa(unescape(encodeURIComponent(svgStr)))}" style="width:100%;max-width:1200px;display:block;margin:0 auto;" />`
+      : '<p style="color:red">Score not rendered.</p>';
+
+    const pw = window.open('', '_blank', 'width=960,height=720');
+    if (!pw) { alert('Pop-up blocked — allow pop-ups for PDF export'); return; }
+    pw.document.write(`<!DOCTYPE html><html><head>
+      <title>${_escXml(p.title)} — ${_escXml(stem.name)}</title>
+      <style>
+        * { margin:0; padding:0; box-sizing:border-box; }
+        body { background:white; font-family:'Times New Roman',serif; padding:24px; }
+        h1 { text-align:center; font-size:20px; margin-bottom:4px; }
+        .sub { text-align:center; font-size:12px; color:#555; margin-bottom:6px; }
+        .bar-lbl { text-align:center; font-size:11px; color:#888; margin-bottom:16px; }
+        .btn { display:block; margin:16px auto; padding:8px 28px; font-size:13px; cursor:pointer; }
+        @media print { .btn { display:none; } @page { size:A4 landscape; margin:1.5cm; } }
+      </style>
+    </head><body>
+      <h1>${_escXml(p.title)}</h1>
+      <div class="sub">${stemInfo}</div>
+      <div class="bar-lbl">${barLabel}</div>
+      ${imgTag}
+      <button class="btn" onclick="window.print()">Print / Save as PDF</button>
+    </body></html>`);
+    pw.document.close();
+  }
+}
diff --git a/js/notation.js b/js/notation.js
index 2fb3074..c4445be 100644
--- a/js/notation.js
+++ b/js/notation.js
@@ -125,6 +125,11 @@ function drawNote(g, x, n, clef, color, beats){
   const nhW = 5.4, nhH = 3.9;
   // ledger lines
   drawLedgers(g, x, n.dia, clef);
+  // accidental (sharp ♯ / flat ♭ / natural ♮) — drawn before notehead
+  if (n.acc) {
+    const accGlyph = n.acc === 'sharp' ? SMUFL.sharp : n.acc === 'flat' ? SMUFL.flat : SMUFL.natural;
+    el("text",{x:x-10,y:y+3.5,class:"smufl",fill:"var(--t-0)","font-size":17,"opacity":"0.9"},g).textContent = accGlyph;
+  }
   if (n.v === 1){ // whole note
     el("ellipse",{cx:x,cy:y,rx:nhW,ry:nhH,fill:"none",stroke:color,"stroke-width":1.7,transform:`rotate(-12 ${x} ${y})`},g);
   } else {
@@ -183,8 +188,45 @@ function drawFlagOrBeam(g, group, color){
 }
 
 // ---- MIDI → notation helpers ----
-const _CHROM_DIA = [0,0,1,1,2,3,3,4,4,5,5,6]; // chromatic step → diatonic (C=0..B=6)
-function midiToDia(pitch){ return Math.floor(pitch/12)*7 + _CHROM_DIA[pitch%12]; }
+
+// [diaStep(0-6), alteration(-1/0/1)] for each pitch class — two spellings
+const _SPELL_SHARP = [[0,0],[0,1],[1,0],[1,1],[2,0],[3,0],[3,1],[4,0],[4,1],[5,0],[5,1],[6,0]];
+const _SPELL_FLAT  = [[0,0],[1,-1],[1,0],[2,-1],[2,0],[3,0],[4,-1],[4,0],[5,-1],[5,0],[6,-1],[6,0]];
+const _STEPS = 'CDEFGAB';
+
+// Returns {dia, acc: 'sharp'|'flat'|'natural'|null}
+// Chooses enharmonic spelling (C#/Db etc.) based on key signature, then compares
+// the note's actual alteration to what the key sig implies for that diatonic step.
+function _midiNoteInfo(pitch, ks) {
+  const pc  = ((pitch % 12) + 12) % 12;
+  const oct = Math.floor(pitch / 12) - 1;
+  const ksSharps = (ks && ks.sharps) || [];
+  const ksFlats  = (ks && ks.flats)  || [];
+  const isAltered = !!_SPELL_SHARP[pc][1]; // true for C#/Db, D#/Eb, F#/Gb, G#/Ab, A#/Bb
+
+  let diaStep, noteAcc;
+  if (!isAltered) {
+    diaStep = _SPELL_SHARP[pc][0]; noteAcc = 0;
+  } else {
+    const sharpBase = _STEPS[_SPELL_SHARP[pc][0]]; // e.g. 'C' for C#
+    const flatBase  = _STEPS[_SPELL_FLAT[pc][0]];  // e.g. 'D' for Db
+    if      (ksSharps.includes(sharpBase)) { diaStep=_SPELL_SHARP[pc][0]; noteAcc=1;  }
+    else if (ksFlats.includes(flatBase))   { diaStep=_SPELL_FLAT[pc][0];  noteAcc=-1; }
+    else if (ksFlats.length > 0)           { diaStep=_SPELL_FLAT[pc][0];  noteAcc=-1; }
+    else                                   { diaStep=_SPELL_SHARP[pc][0]; noteAcc=1;  }
+  }
+
+  const stepName  = _STEPS[diaStep];
+  const keySigAcc = ksSharps.includes(stepName) ? 1 : ksFlats.includes(stepName) ? -1 : 0;
+  const displayAcc = noteAcc === keySigAcc ? null
+    : noteAcc === 0 ? 'natural' : noteAcc === 1 ? 'sharp' : 'flat';
+
+  return { dia: oct * 7 + diaStep, acc: displayAcc };
+}
+
+// Keep for any legacy callers
+function midiToDia(pitch){ return _midiNoteInfo(pitch, null).dia; }
+
 function _qz(b, grid=0.25){ return Math.round(b/grid)*grid; }
 function _beatDurToV(db){
   if(db>=3.5) return {v:1,dot:false};
@@ -197,43 +239,65 @@ function _beatDurToV(db){
   return {v:16,dot:false};
 }
 
-function buildMeasuresFromMidi(midiNotes, beats, bars, tempo){
+function buildMeasuresFromMidi(midiNotes, beats, bars, tempo, barOffset, keySig){
   const bps = tempo / 60;
-  const SLOTS = beats * 4;
+  const off = (barOffset || 0) * beats;
+  // 8th-note grid: notes 0.5 beats apart minimum → ~17px spacing, no visual collision
+  const GRID = 0.5;
+  const SLOTS = beats * 2;
+  const MIN_REST = 1.0; // suppress rests shorter than a quarter note
+
   const events = midiNotes
     .filter(n => !n.drum)
-    .map(n => ({
-      beatStart: _qz(n.start * bps),
-      beatDur:   Math.max(0.25, _qz((n.end - n.start) * bps)),
-      dia:       midiToDia(n.pitch)
-    }))
-    .filter(n => n.beatStart < bars * beats);
+    .map(n => {
+      const info = _midiNoteInfo(n.pitch, keySig);
+      return {
+        beatStart: _qz(n.start * bps, GRID) - off,
+        beatDur:   Math.max(GRID, _qz((n.end - n.start) * bps, GRID)),
+        dia:       info.dia,
+        acc:       info.acc,
+      };
+    })
+    .filter(n => n.beatStart >= 0 && n.beatStart < bars * beats);
 
   const grid = Array.from({length:bars}, ()=>Array(SLOTS).fill(null));
   events.forEach(n => {
     const bar = Math.floor(n.beatStart / beats);
     if(bar < 0 || bar >= bars) return;
-    const slot = Math.round((n.beatStart - bar*beats) * 4);
+    const slot = Math.round((n.beatStart - bar*beats) / GRID);
     if(slot < 0 || slot >= SLOTS) return;
+    // keep highest pitch per slot (most audible note wins)
     if(!grid[bar][slot] || n.dia > grid[bar][slot].dia)
-      grid[bar][slot] = { dia:n.dia, beatInBar:n.beatStart-bar*beats, beatDur:n.beatDur };
+      grid[bar][slot] = { dia:n.dia, acc:n.acc, beatDur:n.beatDur };
   });
 
   return grid.map(row => {
     const notes = [];
     let pos = 0;
+    const barAccShown = new Set();
     for(let s=0; s<SLOTS; s++){
-      const bp = s/4;
-      if(pos > bp+0.001) continue;
+      const bp = s * GRID;
+      if(pos > bp + 0.001) continue;
       const evt = row[s];
       if(evt){
-        if(bp > pos+0.001){ const rv=_beatDurToV(bp-pos); notes.push({dia:34,v:rv.v,dot:rv.dot,beats:bp-pos,rest:true,onset:pos}); }
-        const nv=_beatDurToV(evt.beatDur); const ad=Math.min(evt.beatDur,beats-bp);
-        notes.push({dia:evt.dia,v:nv.v,dot:nv.dot,beats:ad,rest:false,onset:bp});
-        pos=bp+ad;
+        // only insert rest if the gap is big enough to show without overlap
+        if(bp > pos + 0.001){
+          const gap = bp - pos;
+          if(gap >= MIN_REST){ const rv=_beatDurToV(gap); notes.push({dia:34,v:rv.v,dot:rv.dot,beats:gap,rest:true,onset:pos}); }
+        }
+        const nv=_beatDurToV(evt.beatDur); const ad=Math.min(evt.beatDur, beats-bp);
+        const accKey = evt.dia % 7;
+        const showAcc = evt.acc && !barAccShown.has(accKey) ? evt.acc : null;
+        if (evt.acc) barAccShown.add(accKey);
+        notes.push({dia:evt.dia, acc:showAcc, v:nv.v, dot:nv.dot, beats:ad, rest:false, onset:bp});
+        pos = bp + ad;
       }
     }
-    if(pos < beats-0.001){ const rv=_beatDurToV(beats-pos); notes.push({dia:34,v:rv.v,dot:rv.dot,beats:beats-pos,rest:true,onset:pos}); }
+    // trailing rest: only if remainder >= 1 beat
+    if(pos < beats - 0.001){
+      const gap = beats - pos;
+      if(gap >= MIN_REST){ const rv=_beatDurToV(gap); notes.push({dia:34,v:rv.v,dot:rv.dot,beats:gap,rest:true,onset:pos}); }
+    }
     return notes.length ? notes : [{dia:34,v:1,dot:false,beats:beats,rest:true,onset:0}];
   });
 }
@@ -244,10 +308,18 @@ function renderStaff(stem, project, opts){
   const bars = project.bars;
   const clef = stem.clef === "perc" ? "treble" : stem.clef;
   const mW = beats === 3 ? 132 : 168;
-  const firstPad = 78;     // clef + key + time
   const notePadL = 16, notePadR = 14;
+
+  // pre-compute header width so firstPad is always wide enough
+  // clef ends ~x42; key sig: 8.5px/sharp, 8px/flat; time sig: 24px + gap
+  const ks = KEYSIG[project.key] || {sharps:[],flats:[]};
+  const kEndX = 44 + ks.sharps.length * 8.5 + ks.flats.length * 8;
+  const tsX   = Math.max(kEndX + 6, 60);
+  const firstPad = Math.max(78, Math.ceil(tsX + 28)); // 28 = time sig glyph width + gap
+
   const totalW = firstPad + mW*bars + 8;
-  const height = 96;
+  // bass clef needs extra vertical room (E1 open string lands at y≈107)
+  const height = clef === 'bass' ? 148 : 96;
   const svg = el("svg",{ width: totalW, height, viewBox:`0 0 ${totalW} ${height}`, class:"staff-svg" });
   const css = getComputedStyle(document.documentElement);
   const color = css.getPropertyValue(stem.color).trim() || "#9ab";
@@ -262,12 +334,8 @@ function renderStaff(stem, project, opts){
   el("text",{x:10,y:clefGy,class:"smufl",fill:"var(--t-1)","font-size":34},svg).textContent = clefGlyph;
 
   // key signature (sharps/flats)
-  const ks = KEYSIG[project.key] || {sharps:[],flats:[]};
   let kx = 44;
-  const sharpRowDia = { F: stem.clef==="bass"?dabs("F",3):dabs("F",5), C: stem.clef==="bass"?dabs("C",3):dabs("C",5),
-                        G: stem.clef==="bass"?dabs("G",3):dabs("G",5) };
   const accDia = (name)=>{
-    // place near top of staff in correct octave for clef
     const base = clef==="bass"? {F:dabs("F",3),C:dabs("C",3),G:dabs("G",3),A:dabs("A",2),E:dabs("E",3),B:dabs("B",2),D:dabs("D",3)}
                : clef==="alto"? {F:dabs("F",4),C:dabs("C",4),G:dabs("G",4),A:dabs("A",3),E:dabs("E",4),B:dabs("B",3),D:dabs("D",4)}
                :               {F:dabs("F",5),C:dabs("C",5),G:dabs("G",5),A:dabs("A",4),E:dabs("E",5),B:dabs("B",4),D:dabs("D",5)};
@@ -278,10 +346,9 @@ function renderStaff(stem, project, opts){
     ks.flats.forEach(s=>{ const y=yForDia(accDia(s),clef); el("text",{x:kx,y:y+3.2,class:"smufl",fill:"var(--t-1)","font-size":22},svg).textContent=SMUFL.flat; kx+=8; });
   }
 
-  // time signature
-  const tsx = Math.max(kx+6, 60);
-  el("text",{x:tsx,y:STAFF_TOP+SP*1.05+1,class:"smufl ts",fill:"var(--t-0)","font-size":24,"text-anchor":"middle"},svg).textContent = tsNum(project.timeSig[0]);
-  el("text",{x:tsx,y:STAFF_TOP+SP*3.05+1,class:"smufl ts",fill:"var(--t-0)","font-size":24,"text-anchor":"middle"},svg).textContent = tsNum(project.timeSig[1]);
+  // time signature (use pre-computed tsX so it always lands before firstPad)
+  el("text",{x:tsX,y:STAFF_TOP+SP*1.05+1,class:"smufl ts",fill:"var(--t-0)","font-size":24,"text-anchor":"middle"},svg).textContent = tsNum(project.timeSig[0]);
+  el("text",{x:tsX,y:STAFF_TOP+SP*3.05+1,class:"smufl ts",fill:"var(--t-0)","font-size":24,"text-anchor":"middle"},svg).textContent = tsNum(project.timeSig[1]);
 
   // barlines
   for (let b=0;b<=bars;b++){ const x=firstPad+b*mW; el("line",{x1:x,y1:STAFF_TOP,x2:x,y2:STAFF_TOP+4*SP,stroke:b===bars?"var(--line-strong)":"var(--line)","stroke-width":b===bars?2:1},svg); }
@@ -294,7 +361,7 @@ function renderStaff(stem, project, opts){
   }
 
   const measures = (stem.midiNotes && stem.midiNotes.length > 0)
-    ? buildMeasuresFromMidi(stem.midiNotes, beats, bars, project.tempo || 120)
+    ? buildMeasuresFromMidi(stem.midiNotes, beats, bars, project.tempo || 120, project.barOffset || 0, ks)
     : genNotes(stem, beats, bars, rnd);
   const noteG = el("g",{},svg);
 
diff --git a/js/waveform.js b/js/waveform.js
index 629d0ae..9d8f44b 100644
--- a/js/waveform.js
+++ b/js/waveform.js
@@ -50,12 +50,22 @@ function drawWaveform(canvas, stem, opts){
     }
     samples[i] = Math.max(0.02, Math.min(1, v));
   }
-  // fill waveform
-  ctx.globalAlpha = stem.muted ? 0.28 : 1;
+  // fill waveform — real peaks take priority over procedural
   ctx.fillStyle = col;
   ctx.beginPath();
-  for (let i=0;i<n;i++){ const x=i*pxStep, a=samples[i]*maxA; ctx.rect(x, mid-a, pxStep-0.6, a*2); }
-  ctx.globalAlpha = stem.muted ? 0.16 : 0.92;
+  if (opts.peaks && opts.peaks.length > 0) {
+    const P = opts.peaks, Pn = P.length;
+    ctx.globalAlpha = stem.muted ? 0.28 : 0.92;
+    for (let i = 0; i < W; i++) {
+      const pi = Math.min(Pn - 1, Math.floor(i / W * Pn));
+      const a = P[pi] * maxA;
+      ctx.rect(i, mid - a, 1.4, a * 2);
+    }
+  } else {
+    ctx.globalAlpha = stem.muted ? 0.28 : 1;
+    for (let i=0;i<n;i++){ const x=i*pxStep, a=samples[i]*maxA; ctx.rect(x, mid-a, pxStep-0.6, a*2); }
+    ctx.globalAlpha = stem.muted ? 0.16 : 0.92;
+  }
   ctx.fill();
   // center line
   ctx.globalAlpha = 0.5; ctx.strokeStyle = col; ctx.lineWidth=0.6;
diff --git a/main.js b/main.js
new file mode 100644
index 0000000..5cfb544
--- /dev/null
+++ b/main.js
@@ -0,0 +1,189 @@
+const { app, BrowserWindow, dialog, shell, ipcMain } = require('electron');
+const { spawn } = require('child_process');
+const http  = require('http');
+const path  = require('path');
+
+const PORT = 7471;
+let win;
+let server;
+
+// ── Python backend ────────────────────────────────────────────────────────────
+function portInUse() {
+  return new Promise(resolve => {
+    const req = http.get(`http://127.0.0.1:${PORT}/`, res => { res.resume(); resolve(true); });
+    req.on('error', () => resolve(false));
+    req.setTimeout(500, () => { req.destroy(); resolve(false); });
+  });
+}
+
+async function startBackend() {
+  if (await portInUse()) {
+    console.log(`[main] port ${PORT} already in use — reusing existing server`);
+    return;
+  }
+  let spawnCmd, spawnArgs, spawnCwd;
+  if (app.isPackaged) {
+    // Use the bundled server_launch.exe produced by PyInstaller
+    spawnCmd = path.join(process.resourcesPath, 'server_dist', 'server_launch.exe');
+    spawnArgs = [];
+    spawnCwd  = path.join(process.resourcesPath, 'server_dist');
+  } else {
+    spawnCmd  = process.platform === 'win32' ? 'python' : 'python3';
+    spawnArgs = ['-m', 'uvicorn', 'server:app', `--port=${PORT}`, '--log-level=warning'];
+    spawnCwd  = __dirname;
+  }
+  server = spawn(spawnCmd, spawnArgs, {
+    cwd: spawnCwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+  server.stdout.on('data', d => process.stdout.write('[server] ' + d));
+  server.stderr.on('data', d => process.stderr.write('[server] ' + d));
+  server.on('error', err => {
+    dialog.showErrorBox('Backend error',
+      `Could not start Python server:\n${err.message}\n\n` +
+      `Make sure Python is on PATH and run:\n  pip install -r requirements.txt`);
+    app.quit();
+  });
+}
+
+function killBackend() {
+  if (!server) return;
+  const pid = server.pid;
+  // Destroy open pipes so Node stops tracking this child (prevents exit hang)
+  try { server.stdout.destroy(); } catch (_) {}
+  try { server.stderr.destroy(); } catch (_) {}
+  server.unref();
+  server = null;
+  if (process.platform === 'win32') {
+    const tk = spawn('taskkill', ['/pid', pid, '/f', '/t'], { windowsHide: true });
+    tk.unref();
+  } else {
+    try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+  }
+}
+
+// Poll until the server responds (max 60 s)
+function waitForServer() {
+  return new Promise((resolve, reject) => {
+    let attempts = 0;
+    const check = () => {
+      const req = http.get(`http://127.0.0.1:${PORT}/`, res => {
+        res.resume();
+        resolve();
+      });
+      req.on('error', () => {
+        if (++attempts >= 60) return reject(new Error('Server did not start within 60 s'));
+        setTimeout(check, 1000);
+      });
+      req.setTimeout(800, () => req.destroy());
+    };
+    check();
+  });
+}
+
+// ── Window ────────────────────────────────────────────────────────────────────
+async function createWindow() {
+  await startBackend();
+
+  // Show a splash while waiting
+  const splash = new BrowserWindow({
+    width: 380, height: 220,
+    frame: false, alwaysOnTop: true, resizable: false,
+    backgroundColor: '#0a0a0c',
+    webPreferences: { nodeIntegration: false },
+  });
+  splash.loadFile(path.join(__dirname, 'assets', 'splash.html'));
+
+  try {
+    await waitForServer();
+  } catch (err) {
+    splash.close();
+    dialog.showErrorBox('Failed to start', err.message);
+    app.quit();
+    return;
+  }
+
+  win = new BrowserWindow({
+    width: 1440,
+    height: 900,
+    minWidth: 1100,
+    minHeight: 720,
+    frame: false,          // frameless — top bar acts as drag region
+    backgroundColor: '#0a0a0c',
+    show: false,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      webSecurity: false,
+      preload: path.join(__dirname, 'preload.js'),
+    },
+  });
+
+  win.loadURL(`http://127.0.0.1:${PORT}/`);
+
+  win.once('ready-to-show', () => {
+    splash.close();
+    win.show();
+    // inject drag region + window controls CSS/JS after load
+    win.webContents.insertCSS(`
+      header.top { -webkit-app-region: drag; }
+      header.top button,
+      header.top input,
+      header.top .meter,
+      header.top .omnibox { -webkit-app-region: no-drag; }
+      .win-controls {
+        display: flex; align-items: center; gap: 6px;
+        -webkit-app-region: no-drag; padding: 0 8px;
+      }
+      .win-btn {
+        width: 12px; height: 12px; border-radius: 50%;
+        border: none; cursor: pointer; outline: none;
+      }
+      .win-btn.close  { background: #ff5f57; }
+      .win-btn.min    { background: #febc2e; }
+      .win-btn.max    { background: #28c840; }
+    `);
+    win.webContents.executeJavaScript(`
+      (function() {
+        const ctrl = document.createElement('div');
+        ctrl.className = 'win-controls';
+        ctrl.innerHTML =
+          '<button class="win-btn close"  title="Close">'    +
+          '<button class="win-btn min"    title="Minimise">' +
+          '<button class="win-btn max"    title="Maximise">';
+        document.querySelector('header.top')?.prepend(ctrl);
+        ctrl.querySelector('.close').onclick = () => window.electronAPI?.close();
+        ctrl.querySelector('.min').onclick   = () => window.electronAPI?.minimize();
+        ctrl.querySelector('.max').onclick   = () => window.electronAPI?.maximize();
+      })();
+    `);
+  });
+
+  win.on('closed', () => { win = null; });
+
+  // Open external links in browser, not Electron
+  win.webContents.setWindowOpenHandler(({ url }) => {
+    shell.openExternal(url);
+    return { action: 'deny' };
+  });
+}
+
+// ── IPC (window controls from renderer) ──────────────────────────────────────
+ipcMain.on('win:close',    () => win?.close());
+ipcMain.on('win:minimize', () => win?.minimize());
+ipcMain.on('win:maximize', () => win?.isMaximized() ? win.unmaximize() : win.maximize());
+
+// ── App lifecycle ─────────────────────────────────────────────────────────────
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+  killBackend();
+  app.exit(0);
+});
+
+app.on('before-quit', killBackend);
+
+app.on('activate', () => {
+  if (!win) createWindow();
+});
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..617d22b
--- /dev/null
+++ b/main.py
@@ -0,0 +1,52 @@
+"""
+Aegis Score Studio — desktop entry point
+Launches PySide6 window + embedded FastAPI backend on a background thread.
+"""
+from __future__ import annotations
+
+import sys
+import threading
+import uvicorn
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QUrl, Qt
+
+from backend.api.app import create_app
+from backend.bridge import AppBridge
+
+
+def _run_backend(host: str = "127.0.0.1", port: int = 7471) -> None:
+    fastapi_app = create_app()
+    uvicorn.run(fastapi_app, host=host, port=port, log_level="warning")
+
+
+def main() -> int:
+    # High-DPI + QML style
+    QApplication.setHighDpiScaleFactorRoundingPolicy(
+        Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
+    )
+    app = QApplication(sys.argv)
+    app.setApplicationName("Aegis Score Studio")
+    app.setOrganizationName("AegisAudio")
+    app.setApplicationVersion("0.1.0")
+
+    # Start backend
+    backend_thread = threading.Thread(
+        target=_run_backend, daemon=True, name="aegis-backend"
+    )
+    backend_thread.start()
+
+    # QML engine
+    engine = QQmlApplicationEngine()
+    bridge = AppBridge(parent=app)
+    engine.rootContext().setContextProperty("AppBridge", bridge)
+    engine.load(QUrl("frontend/qml/views/MainWindow.qml"))
+
+    if not engine.rootObjects():
+        return 1
+
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..24fcd9a
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,4112 @@
+{
+  "name": "aegis-score-studio",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "aegis-score-studio",
+      "version": "1.0.0",
+      "devDependencies": {
+        "electron": "^31.0.0",
+        "electron-builder": "^24.0.0"
+      }
+    },
+    "node_modules/@develar/schema-utils": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz",
+      "integrity": "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.0",
+        "ajv-keywords": "^3.4.1"
+      },
+      "engines": {
+        "node": ">= 8.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/@electron/asar": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.4.1.tgz",
+      "integrity": "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "commander": "^5.0.0",
+        "glob": "^7.1.6",
+        "minimatch": "^3.0.4"
+      },
+      "bin": {
+        "asar": "bin/asar.js"
+      },
+      "engines": {
+        "node": ">=10.12.0"
+      }
+    },
+    "node_modules/@electron/asar/node_modules/brace-expansion": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
+      "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@electron/asar/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/@electron/get": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@electron/get/-/get-2.0.3.tgz",
+      "integrity": "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "env-paths": "^2.2.0",
+        "fs-extra": "^8.1.0",
+        "got": "^11.8.5",
+        "progress": "^2.0.3",
+        "semver": "^6.2.0",
+        "sumchecker": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "global-agent": "^3.0.0"
+      }
+    },
+    "node_modules/@electron/notarize": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.2.1.tgz",
+      "integrity": "sha512-aL+bFMIkpR0cmmj5Zgy0LMKEpgy43/hw5zadEArgmAMWWlKc5buwFvFT9G/o/YJkvXAJm5q3iuTuLaiaXW39sg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "fs-extra": "^9.0.1",
+        "promise-retry": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/@electron/notarize/node_modules/fs-extra": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "at-least-node": "^1.0.0",
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@electron/notarize/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/@electron/notarize/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/@electron/osx-sign": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.0.5.tgz",
+      "integrity": "sha512-k9ZzUQtamSoweGQDV2jILiRIHUu7lYlJ3c6IEmjv1hC17rclE+eb9U+f6UFlOOETo0JzY1HNlXy4YOlCvl+Lww==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "compare-version": "^0.1.2",
+        "debug": "^4.3.4",
+        "fs-extra": "^10.0.0",
+        "isbinaryfile": "^4.0.8",
+        "minimist": "^1.2.6",
+        "plist": "^3.0.5"
+      },
+      "bin": {
+        "electron-osx-flat": "bin/electron-osx-flat.js",
+        "electron-osx-sign": "bin/electron-osx-sign.js"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/@electron/osx-sign/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@electron/osx-sign/node_modules/isbinaryfile": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz",
+      "integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/gjtorikian/"
+      }
+    },
+    "node_modules/@electron/osx-sign/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/@electron/osx-sign/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/@electron/universal": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@electron/universal/-/universal-1.5.1.tgz",
+      "integrity": "sha512-kbgXxyEauPJiQQUNG2VgUeyfQNFk6hBF11ISN2PNI6agUgPl55pv4eQmaqHzTAzchBvqZ2tQuRVaPStGf0mxGw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@electron/asar": "^3.2.1",
+        "@malept/cross-spawn-promise": "^1.1.0",
+        "debug": "^4.3.1",
+        "dir-compare": "^3.0.0",
+        "fs-extra": "^9.0.1",
+        "minimatch": "^3.0.4",
+        "plist": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/@electron/universal/node_modules/brace-expansion": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
+      "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@electron/universal/node_modules/fs-extra": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "at-least-node": "^1.0.0",
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@electron/universal/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/@electron/universal/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/@electron/universal/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@isaacs/cliui/node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/@malept/cross-spawn-promise": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
+      "integrity": "sha512-RTBGWL5FWQcg9orDOCcp4LvItNzUPcyEU9bwaeJX0rJ1IQxzucC48Y0/sQLp/g6t99IQgAlGIaesJS+gTn7tVQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/malept"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund"
+        }
+      ],
+      "license": "Apache-2.0",
+      "dependencies": {
+        "cross-spawn": "^7.0.1"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@malept/flatpak-bundler": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@malept/flatpak-bundler/-/flatpak-bundler-0.4.0.tgz",
+      "integrity": "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "fs-extra": "^9.0.0",
+        "lodash": "^4.17.15",
+        "tmp-promise": "^3.0.2"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/@malept/flatpak-bundler/node_modules/fs-extra": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "at-least-node": "^1.0.0",
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@malept/flatpak-bundler/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/@malept/flatpak-bundler/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@sindresorhus/is": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+      "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
+      }
+    },
+    "node_modules/@szmarczak/http-timer": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz",
+      "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "defer-to-connect": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@tootallnate/once": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.1.tgz",
+      "integrity": "sha512-HqmEUIGRJ5fSXchkVgR5F7qn48bDBzv0kWj/Kfu5e6uci4UlEeng4331LnBkWffb++Ei3FOVLxo8JJWMFBDMeQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@types/cacheable-request": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",
+      "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/http-cache-semantics": "*",
+        "@types/keyv": "^3.1.4",
+        "@types/node": "*",
+        "@types/responselike": "^1.0.0"
+      }
+    },
+    "node_modules/@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
+    "node_modules/@types/fs-extra": {
+      "version": "9.0.13",
+      "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz",
+      "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/http-cache-semantics": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/keyv": {
+      "version": "3.1.4",
+      "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",
+      "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.42",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.42.tgz",
+      "integrity": "sha512-5L7SUaFC1RyDraj2yRhyBzHTobyXHmohD100CChNtyPyleoq37Mqab5Gn8XEKI04dfN/oqPdpHk38MgcQWHbZg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/plist": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@types/plist/-/plist-3.0.5.tgz",
+      "integrity": "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@types/node": "*",
+        "xmlbuilder": ">=11.0.1"
+      }
+    },
+    "node_modules/@types/responselike": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz",
+      "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/verror": {
+      "version": "1.10.11",
+      "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.11.tgz",
+      "integrity": "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/@types/yauzl": {
+      "version": "2.10.3",
+      "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+      "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@xmldom/xmldom": {
+      "version": "0.9.10",
+      "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.9.10.tgz",
+      "integrity": "sha512-A9gOqLdi6cV4ibazAjcQufGj0B1y/vDqYrcuP6d/6x8P27gRS8643Dj9o1dEKtB6O7fwxb2FgBmJS2mX7gpvdw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.6"
+      }
+    },
+    "node_modules/7zip-bin": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz",
+      "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.15.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ajv-keywords": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "ajv": "^6.9.1"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/app-builder-bin": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-4.0.0.tgz",
+      "integrity": "sha512-xwdG0FJPQMe0M0UA4Tz0zEB8rBJTRA5a476ZawAqiBkMv16GRK5xpXThOjMaEOFnZ6zabejjG4J3da0SXG63KA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/app-builder-lib": {
+      "version": "24.13.3",
+      "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-24.13.3.tgz",
+      "integrity": "sha512-FAzX6IBit2POXYGnTCT8YHFO/lr5AapAII6zzhQO3Rw4cEDOgK+t1xhLc5tNcKlicTHlo9zxIwnYCX9X2DLkig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@develar/schema-utils": "~2.6.5",
+        "@electron/notarize": "2.2.1",
+        "@electron/osx-sign": "1.0.5",
+        "@electron/universal": "1.5.1",
+        "@malept/flatpak-bundler": "^0.4.0",
+        "@types/fs-extra": "9.0.13",
+        "async-exit-hook": "^2.0.1",
+        "bluebird-lst": "^1.0.9",
+        "builder-util": "24.13.1",
+        "builder-util-runtime": "9.2.4",
+        "chromium-pickle-js": "^0.2.0",
+        "debug": "^4.3.4",
+        "ejs": "^3.1.8",
+        "electron-publish": "24.13.1",
+        "form-data": "^4.0.0",
+        "fs-extra": "^10.1.0",
+        "hosted-git-info": "^4.1.0",
+        "is-ci": "^3.0.0",
+        "isbinaryfile": "^5.0.0",
+        "js-yaml": "^4.1.0",
+        "lazy-val": "^1.0.5",
+        "minimatch": "^5.1.1",
+        "read-config-file": "6.3.2",
+        "sanitize-filename": "^1.6.3",
+        "semver": "^7.3.8",
+        "tar": "^6.1.12",
+        "temp-file": "^3.4.0"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "dmg-builder": "24.13.3",
+        "electron-builder-squirrel-windows": "24.13.3"
+      }
+    },
+    "node_modules/app-builder-lib/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/app-builder-lib/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/app-builder-lib/node_modules/semver": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.3.tgz",
+      "integrity": "sha512-wnilbGyMxzbY7dNOl7jpKbLSjcfeweJWU5j4+u5qW+6/wuGD9KzIGOyZnQVSBM9E7DtWaaH3CyHkppYrKYoxwg==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/app-builder-lib/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/archiver": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/archiver/-/archiver-5.3.2.tgz",
+      "integrity": "sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "archiver-utils": "^2.1.0",
+        "async": "^3.2.4",
+        "buffer-crc32": "^0.2.1",
+        "readable-stream": "^3.6.0",
+        "readdir-glob": "^1.1.2",
+        "tar-stream": "^2.2.0",
+        "zip-stream": "^4.1.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/archiver-utils": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-2.1.0.tgz",
+      "integrity": "sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "glob": "^7.1.4",
+        "graceful-fs": "^4.2.0",
+        "lazystream": "^1.0.0",
+        "lodash.defaults": "^4.2.0",
+        "lodash.difference": "^4.5.0",
+        "lodash.flatten": "^4.4.0",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.union": "^4.6.0",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^2.0.0"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/archiver-utils/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/archiver-utils/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/archiver-utils/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/assert-plus": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",
+      "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/astral-regex": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
+      "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/async-exit-hook": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz",
+      "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/at-least-node": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+      "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 4.0.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/bl": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
+      "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "buffer": "^5.5.0",
+        "inherits": "^2.0.4",
+        "readable-stream": "^3.4.0"
+      }
+    },
+    "node_modules/bluebird": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
+      "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/bluebird-lst": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/bluebird-lst/-/bluebird-lst-1.0.9.tgz",
+      "integrity": "sha512-7B1Rtx82hjnSD4PGLAjVWeYH3tHAcVUmChh85a3lltKQm6FresXh9ErQo6oAv6CqxttczC3/kEg8SY5NluPuUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bluebird": "^3.5.5"
+      }
+    },
+    "node_modules/boolean": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz",
+      "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==",
+      "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.1.tgz",
+      "integrity": "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/buffer-equal": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.1.tgz",
+      "integrity": "sha512-QoV3ptgEaQpvVwbXdSO39iqPQTCxSF7A5U99AxbHYqUdCizL/lH2Z0A2y6nbZucxMEOtNyZfG2s6gsVugGpKkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/builder-util": {
+      "version": "24.13.1",
+      "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-24.13.1.tgz",
+      "integrity": "sha512-NhbCSIntruNDTOVI9fdXz0dihaqX2YuE1D6zZMrwiErzH4ELZHE6mdiB40wEgZNprDia+FghRFgKoAqMZRRjSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/debug": "^4.1.6",
+        "7zip-bin": "~5.2.0",
+        "app-builder-bin": "4.0.0",
+        "bluebird-lst": "^1.0.9",
+        "builder-util-runtime": "9.2.4",
+        "chalk": "^4.1.2",
+        "cross-spawn": "^7.0.3",
+        "debug": "^4.3.4",
+        "fs-extra": "^10.1.0",
+        "http-proxy-agent": "^5.0.0",
+        "https-proxy-agent": "^5.0.1",
+        "is-ci": "^3.0.0",
+        "js-yaml": "^4.1.0",
+        "source-map-support": "^0.5.19",
+        "stat-mode": "^1.0.0",
+        "temp-file": "^3.4.0"
+      }
+    },
+    "node_modules/builder-util-runtime": {
+      "version": "9.2.4",
+      "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.2.4.tgz",
+      "integrity": "sha512-upp+biKpN/XZMLim7aguUyW8s0FUpDvOtK6sbanMFDAMBzpHDqdhgVYm6zc9HJ6nWo7u2Lxk60i2M6Jd3aiNrA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.4",
+        "sax": "^1.2.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/builder-util/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/builder-util/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/builder-util/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/cacheable-lookup": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz",
+      "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.6.0"
+      }
+    },
+    "node_modules/cacheable-request": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz",
+      "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "clone-response": "^1.0.2",
+        "get-stream": "^5.1.0",
+        "http-cache-semantics": "^4.0.0",
+        "keyv": "^4.0.0",
+        "lowercase-keys": "^2.0.0",
+        "normalize-url": "^6.0.1",
+        "responselike": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/chromium-pickle-js": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/chromium-pickle-js/-/chromium-pickle-js-0.2.0.tgz",
+      "integrity": "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ci-info": {
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
+      "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/sibiraj-s"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cli-truncate": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz",
+      "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "slice-ansi": "^3.0.0",
+        "string-width": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clone-response": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz",
+      "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mimic-response": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/commander": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/compare-version": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz",
+      "integrity": "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/compress-commons": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-4.1.2.tgz",
+      "integrity": "sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "buffer-crc32": "^0.2.13",
+        "crc32-stream": "^4.0.2",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/config-file-ts": {
+      "version": "0.2.6",
+      "resolved": "https://registry.npmjs.org/config-file-ts/-/config-file-ts-0.2.6.tgz",
+      "integrity": "sha512-6boGVaglwblBgJqGyxm4+xCmEGcWgnWHSWHY5jad58awQhB6gftq0G8HbzU39YqCIYHMLAiL1yjwiZ36m/CL8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "glob": "^10.3.10",
+        "typescript": "^5.3.3"
+      }
+    },
+    "node_modules/config-file-ts/node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/config-file-ts/node_modules/minimatch": {
+      "version": "9.0.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/config-file-ts/node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+      "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/crc": {
+      "version": "3.8.0",
+      "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz",
+      "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "buffer": "^5.1.0"
+      }
+    },
+    "node_modules/crc-32": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz",
+      "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "bin": {
+        "crc32": "bin/crc32.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/crc32-stream": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-4.0.3.tgz",
+      "integrity": "sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "readable-stream": "^3.4.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decompress-response": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+      "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mimic-response": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/decompress-response/node_modules/mimic-response": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+      "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/defer-to-connect": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
+      "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/define-properties": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "define-data-property": "^1.0.1",
+        "has-property-descriptors": "^1.0.0",
+        "object-keys": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/detect-node": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
+      "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/dir-compare": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-3.3.0.tgz",
+      "integrity": "sha512-J7/et3WlGUCxjdnD3HAAzQ6nsnc0WL6DD7WcwJb7c39iH1+AWfg+9OqzJNaI6PkBwBvm1mhZNL9iY/nRiZXlPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal": "^1.0.0",
+        "minimatch": "^3.0.4"
+      }
+    },
+    "node_modules/dir-compare/node_modules/brace-expansion": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
+      "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/dir-compare/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/dmg-builder": {
+      "version": "24.13.3",
+      "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-24.13.3.tgz",
+      "integrity": "sha512-rcJUkMfnJpfCboZoOOPf4L29TRtEieHNOeAbYPWPxlaBw/Z1RKrRA86dOI9rwaI4tQSc/RD82zTNHprfUHXsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "app-builder-lib": "24.13.3",
+        "builder-util": "24.13.1",
+        "builder-util-runtime": "9.2.4",
+        "fs-extra": "^10.1.0",
+        "iconv-lite": "^0.6.2",
+        "js-yaml": "^4.1.0"
+      },
+      "optionalDependencies": {
+        "dmg-license": "^1.0.11"
+      }
+    },
+    "node_modules/dmg-builder/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/dmg-builder/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/dmg-builder/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/dmg-license": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/dmg-license/-/dmg-license-1.0.11.tgz",
+      "integrity": "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "dependencies": {
+        "@types/plist": "^3.0.1",
+        "@types/verror": "^1.10.3",
+        "ajv": "^6.10.0",
+        "crc": "^3.8.0",
+        "iconv-corefoundation": "^1.1.7",
+        "plist": "^3.0.4",
+        "smart-buffer": "^4.0.2",
+        "verror": "^1.10.0"
+      },
+      "bin": {
+        "dmg-license": "bin/dmg-license.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-9.0.2.tgz",
+      "integrity": "sha512-I9OvvrHp4pIARv4+x9iuewrWycX6CcZtoAu1XrzPxc5UygMJXJZYmBsynku8IkrJwgypE5DGNjDPmPRhDCptUg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/dotenv-expand": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-5.1.0.tgz",
+      "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==",
+      "dev": true,
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ejs": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+      "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "jake": "^10.8.5"
+      },
+      "bin": {
+        "ejs": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/electron": {
+      "version": "31.7.7",
+      "resolved": "https://registry.npmjs.org/electron/-/electron-31.7.7.tgz",
+      "integrity": "sha512-HZtZg8EHsDGnswFt0QeV8If8B+et63uD6RJ7I4/xhcXqmTIbI08GoubX/wm+HdY0DwcuPe1/xsgqpmYvjdjRoA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@electron/get": "^2.0.0",
+        "@types/node": "^20.9.0",
+        "extract-zip": "^2.0.1"
+      },
+      "bin": {
+        "electron": "cli.js"
+      },
+      "engines": {
+        "node": ">= 12.20.55"
+      }
+    },
+    "node_modules/electron-builder": {
+      "version": "24.13.3",
+      "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-24.13.3.tgz",
+      "integrity": "sha512-yZSgVHft5dNVlo31qmJAe4BVKQfFdwpRw7sFp1iQglDRCDD6r22zfRJuZlhtB5gp9FHUxCMEoWGq10SkCnMAIg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "app-builder-lib": "24.13.3",
+        "builder-util": "24.13.1",
+        "builder-util-runtime": "9.2.4",
+        "chalk": "^4.1.2",
+        "dmg-builder": "24.13.3",
+        "fs-extra": "^10.1.0",
+        "is-ci": "^3.0.0",
+        "lazy-val": "^1.0.5",
+        "read-config-file": "6.3.2",
+        "simple-update-notifier": "2.0.0",
+        "yargs": "^17.6.2"
+      },
+      "bin": {
+        "electron-builder": "cli.js",
+        "install-app-deps": "install-app-deps.js"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/electron-builder-squirrel-windows": {
+      "version": "24.13.3",
+      "resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-24.13.3.tgz",
+      "integrity": "sha512-oHkV0iogWfyK+ah9ZIvMDpei1m9ZRpdXcvde1wTpra2U8AFDNNpqJdnin5z+PM1GbQ5BoaKCWas2HSjtR0HwMg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "app-builder-lib": "24.13.3",
+        "archiver": "^5.3.1",
+        "builder-util": "24.13.1",
+        "fs-extra": "^10.1.0"
+      }
+    },
+    "node_modules/electron-builder-squirrel-windows/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/electron-builder-squirrel-windows/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/electron-builder-squirrel-windows/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/electron-builder/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/electron-builder/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/electron-builder/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/electron-publish": {
+      "version": "24.13.1",
+      "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-24.13.1.tgz",
+      "integrity": "sha512-2ZgdEqJ8e9D17Hwp5LEq5mLQPjqU3lv/IALvgp+4W8VeNhryfGhYEQC/PgDPMrnWUp+l60Ou5SJLsu+k4mhQ8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/fs-extra": "^9.0.11",
+        "builder-util": "24.13.1",
+        "builder-util-runtime": "9.2.4",
+        "chalk": "^4.1.2",
+        "fs-extra": "^10.1.0",
+        "lazy-val": "^1.0.5",
+        "mime": "^2.5.2"
+      }
+    },
+    "node_modules/electron-publish/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/electron-publish/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/electron-publish/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/env-paths": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+      "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/err-code": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz",
+      "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es6-error": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
+      "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/extract-zip": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+      "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "get-stream": "^5.1.0",
+        "yauzl": "^2.10.0"
+      },
+      "bin": {
+        "extract-zip": "cli.js"
+      },
+      "engines": {
+        "node": ">= 10.17.0"
+      },
+      "optionalDependencies": {
+        "@types/yauzl": "^2.9.1"
+      }
+    },
+    "node_modules/extsprintf": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz",
+      "integrity": "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==",
+      "dev": true,
+      "engines": [
+        "node >=0.6.0"
+      ],
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pend": "~1.2.0"
+      }
+    },
+    "node_modules/filelist": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+      "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.0.1"
+      }
+    },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fs-constants": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
+      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/fs-extra": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
+      "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^4.0.0",
+        "universalify": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=6 <7 || >=8"
+      }
+    },
+    "node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-stream": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+      "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob/node_modules/brace-expansion": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
+      "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/global-agent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz",
+      "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "dependencies": {
+        "boolean": "^3.0.1",
+        "es6-error": "^4.1.1",
+        "matcher": "^3.0.0",
+        "roarr": "^2.15.3",
+        "semver": "^7.3.2",
+        "serialize-error": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=10.0"
+      }
+    },
+    "node_modules/global-agent/node_modules/semver": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.3.tgz",
+      "integrity": "sha512-wnilbGyMxzbY7dNOl7jpKbLSjcfeweJWU5j4+u5qW+6/wuGD9KzIGOyZnQVSBM9E7DtWaaH3CyHkppYrKYoxwg==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/globalthis": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "define-properties": "^1.2.1",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/got": {
+      "version": "11.8.6",
+      "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz",
+      "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sindresorhus/is": "^4.0.0",
+        "@szmarczak/http-timer": "^4.0.5",
+        "@types/cacheable-request": "^6.0.1",
+        "@types/responselike": "^1.0.0",
+        "cacheable-lookup": "^5.0.3",
+        "cacheable-request": "^7.0.2",
+        "decompress-response": "^6.0.0",
+        "http2-wrapper": "^1.0.0-beta.5.2",
+        "lowercase-keys": "^2.0.0",
+        "p-cancelable": "^2.0.0",
+        "responselike": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/got?sponsor=1"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/hosted-git-info": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz",
+      "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/http-cache-semantics": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+      "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+      "dev": true,
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz",
+      "integrity": "sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tootallnate/once": "2",
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/http2-wrapper": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz",
+      "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "quick-lru": "^5.1.1",
+        "resolve-alpn": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=10.19.0"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/iconv-corefoundation": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz",
+      "integrity": "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "dependencies": {
+        "cli-truncate": "^2.1.0",
+        "node-addon-api": "^1.6.3"
+      },
+      "engines": {
+        "node": "^8.11.2 || >=10"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/is-ci": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz",
+      "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ci-info": "^3.2.0"
+      },
+      "bin": {
+        "is-ci": "bin.js"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/isbinaryfile": {
+      "version": "5.0.7",
+      "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.7.tgz",
+      "integrity": "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/gjtorikian/"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
+    "node_modules/jake": {
+      "version": "10.9.4",
+      "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+      "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "async": "^3.2.6",
+        "filelist": "^1.0.4",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "jake": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/js-yaml": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz",
+      "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stringify-safe": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+      "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
+      "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",
+      "dev": true,
+      "license": "MIT",
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/lazy-val": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",
+      "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lazystream": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz",
+      "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "readable-stream": "^2.0.5"
+      },
+      "engines": {
+        "node": ">= 0.6.3"
+      }
+    },
+    "node_modules/lazystream/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/lazystream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/lazystream/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.defaults": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz",
+      "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/lodash.difference": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz",
+      "integrity": "sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/lodash.flatten": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz",
+      "integrity": "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/lodash.union": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz",
+      "integrity": "sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/lowercase-keys": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz",
+      "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/matcher": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
+      "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "escape-string-regexp": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mime": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
+      "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mimic-response": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz",
+      "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-addon-api": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",
+      "integrity": "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/normalize-url": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz",
+      "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/p-cancelable": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz",
+      "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/path-scurry/node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/plist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.1.tgz",
+      "integrity": "sha512-ZIfcLJC+7E7FBFnDxm9MPmt7D+DidyQ26lewieO75AdhA2ayMtsJSES0iWzqJQbcVRSrTufQoy0DR94xHue0oA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@xmldom/xmldom": "^0.9.10",
+        "base64-js": "^1.5.1",
+        "xmlbuilder": "^15.1.1"
+      },
+      "engines": {
+        "node": ">=10.4.0"
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/promise-retry": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz",
+      "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "err-code": "^2.0.2",
+        "retry": "^0.12.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/pump": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz",
+      "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/quick-lru": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+      "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-config-file": {
+      "version": "6.3.2",
+      "resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-6.3.2.tgz",
+      "integrity": "sha512-M80lpCjnE6Wt6zb98DoW8WHR09nzMSpu8XHtPkiTHrJ5Az9CybfeQhTJ8D7saeBHpGhLPIVyA8lcL6ZmdKwY6Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "config-file-ts": "^0.2.4",
+        "dotenv": "^9.0.2",
+        "dotenv-expand": "^5.1.0",
+        "js-yaml": "^4.1.0",
+        "json5": "^2.2.0",
+        "lazy-val": "^1.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/readdir-glob": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz",
+      "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "minimatch": "^5.1.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-alpn": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+      "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/responselike": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz",
+      "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lowercase-keys": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/retry": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+      "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/roarr": {
+      "version": "2.15.4",
+      "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz",
+      "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "dependencies": {
+        "boolean": "^3.0.1",
+        "detect-node": "^2.0.4",
+        "globalthis": "^1.0.1",
+        "json-stringify-safe": "^5.0.1",
+        "semver-compare": "^1.0.0",
+        "sprintf-js": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/sanitize-filename": {
+      "version": "1.6.4",
+      "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.4.tgz",
+      "integrity": "sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg==",
+      "dev": true,
+      "license": "WTFPL OR ISC",
+      "dependencies": {
+        "truncate-utf8-bytes": "^1.0.0"
+      }
+    },
+    "node_modules/sax": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=11.0.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/semver-compare": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
+      "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/serialize-error": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",
+      "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "type-fest": "^0.13.1"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/simple-update-notifier/node_modules/semver": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.3.tgz",
+      "integrity": "sha512-wnilbGyMxzbY7dNOl7jpKbLSjcfeweJWU5j4+u5qW+6/wuGD9KzIGOyZnQVSBM9E7DtWaaH3CyHkppYrKYoxwg==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/slice-ansi": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz",
+      "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "astral-regex": "^2.0.0",
+        "is-fullwidth-code-point": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/sprintf-js": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "optional": true
+    },
+    "node_modules/stat-mode": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",
+      "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/sumchecker": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",
+      "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "debug": "^4.1.0"
+      },
+      "engines": {
+        "node": ">= 8.0"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "deprecated": "Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tar-stream": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
+      "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "bl": "^4.0.3",
+        "end-of-stream": "^1.4.1",
+        "fs-constants": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/temp-file": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/temp-file/-/temp-file-3.4.0.tgz",
+      "integrity": "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "async-exit-hook": "^2.0.1",
+        "fs-extra": "^10.0.0"
+      }
+    },
+    "node_modules/temp-file/node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/temp-file/node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/temp-file/node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/tmp": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.7.tgz",
+      "integrity": "sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/tmp-promise": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz",
+      "integrity": "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tmp": "^0.2.0"
+      }
+    },
+    "node_modules/truncate-utf8-bytes": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
+      "integrity": "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==",
+      "dev": true,
+      "license": "WTFPL",
+      "dependencies": {
+        "utf8-byte-length": "^1.0.1"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",
+      "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "optional": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/universalify": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
+      "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4.0.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/utf8-byte-length": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz",
+      "integrity": "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==",
+      "dev": true,
+      "license": "(WTFPL OR MIT)"
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/verror": {
+      "version": "1.10.1",
+      "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.1.tgz",
+      "integrity": "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "assert-plus": "^1.0.0",
+        "core-util-is": "1.0.2",
+        "extsprintf": "^1.2.0"
+      },
+      "engines": {
+        "node": ">=0.6.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/xmlbuilder": {
+      "version": "15.1.1",
+      "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
+      "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
+    },
+    "node_modules/zip-stream": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-4.1.1.tgz",
+      "integrity": "sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "archiver-utils": "^3.0.4",
+        "compress-commons": "^4.1.2",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/zip-stream/node_modules/archiver-utils": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-3.0.4.tgz",
+      "integrity": "sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "glob": "^7.2.3",
+        "graceful-fs": "^4.2.0",
+        "lazystream": "^1.0.0",
+        "lodash.defaults": "^4.2.0",
+        "lodash.difference": "^4.5.0",
+        "lodash.flatten": "^4.4.0",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.union": "^4.6.0",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..3c89dd4
--- /dev/null
+++ b/package.json
@@ -0,0 +1,48 @@
+{
+  "name": "aegis-score-studio",
+  "version": "1.0.0",
+  "description": "AI music deconstruction workstation",
+  "main": "main.js",
+  "scripts": {
+    "start": "electron .",
+    "build": "electron-builder"
+  },
+  "devDependencies": {
+    "electron": "^31.0.0",
+    "electron-builder": "^24.0.0"
+  },
+  "build": {
+    "appId": "com.aegis.score-studio",
+    "productName": "Aegis Score Studio",
+    "directories": {
+      "output": "dist"
+    },
+    "files": [
+      "main.js",
+      "index.html",
+      "css/**",
+      "js/**",
+      "server.py",
+      "requirements.txt"
+    ],
+    "win": {
+      "target": "nsis"
+    },
+    "mac": {
+      "target": "dmg",
+      "icon": "css/icon.icns"
+    },
+    "linux": {
+      "target": "AppImage"
+    },
+    "extraResources": [
+      {
+        "from": "dist/server_dist",
+        "to": "server_dist",
+        "filter": [
+          "**/*"
+        ]
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/plugins/.gitkeep b/plugins/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/preload.js b/preload.js
new file mode 100644
index 0000000..2966c2e
--- /dev/null
+++ b/preload.js
@@ -0,0 +1,7 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('electronAPI', {
+  close:    () => ipcRenderer.send('win:close'),
+  minimize: () => ipcRenderer.send('win:minimize'),
+  maximize: () => ipcRenderer.send('win:maximize'),
+});
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..ff9d5e6
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=72", "wheel"]
+build-backend = "setuptools.backends.legacy:build"
+
+[project]
+name = "aegis-score-studio"
+version = "0.1.0"
+description = "AI music deconstruction workstation"
+requires-python = ">=3.13"
+dependencies = [
+    "PySide6>=6.9",
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.30",
+    "pydantic>=2.7",
+    "yt-dlp>=2024.8",
+    "demucs>=4.0",
+    "librosa>=0.10",
+    "pretty_midi>=0.2",
+    "soundfile>=0.12",
+    "numpy>=2.0",
+    "scipy>=1.13",
+    "sqlalchemy>=2.0",
+    "alembic>=1.13",
+    "aiofiles>=23.2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+    "pytest-qt>=4.4",
+    "ruff>=0.5",
+    "mypy>=1.10",
+    "black>=24",
+]
+
+[tool.ruff]
+target-version = "py313"
+line-length = 100
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
diff --git a/requirements.txt b/requirements.txt
index 522f0e8..2a77276 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,3 +8,4 @@ librosa>=0.10.0
 pretty-midi>=0.2.10
 soundfile>=0.12.1
 python-multipart
+omnizart
diff --git a/scripts/.gitkeep b/scripts/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/scripts/build_windows.py b/scripts/build_windows.py
new file mode 100644
index 0000000..97aa951
--- /dev/null
+++ b/scripts/build_windows.py
@@ -0,0 +1,238 @@
+"""
+Aegis Score Studio — Windows portable build script.
+
+Usage:
+    python scripts/build_windows.py [--zip] [--skip-deps-check]
+
+Output:
+    dist/AegisScoreStudio/          ← run AegisScoreStudio.exe from here
+    dist/AegisScoreStudio.zip       ← (with --zip) portable archive
+
+Notes:
+- Uses --onedir (NOT --onefile) because PySide6 QML plugins cannot be
+  reliably packed into a single executable on Windows.
+- torch / demucs / librosa are large (~4 GB). First run downloads models.
+- The exe expects ffmpeg.exe on PATH or in its own directory.
+"""
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+ROOT     = Path(__file__).resolve().parent.parent
+DIST_DIR = ROOT / "dist"
+BUILD_DIR = ROOT / "build"
+OUT_DIR  = DIST_DIR / "AegisScoreStudio"
+OUT_ZIP  = DIST_DIR / "AegisScoreStudio.zip"
+ICON     = ROOT / "assets" / "icons" / "app.ico"
+SPEC_FILE = ROOT / "AegisScoreStudio.spec"
+
+
+def _pyside6_path() -> Path:
+    import PySide6
+    return Path(PySide6.__file__).parent
+
+
+def _check_deps() -> None:
+    required = ["PyInstaller", "PySide6", "fastapi", "uvicorn"]
+    missing = []
+    for pkg in required:
+        try:
+            __import__(pkg.replace("-", "_").lower())
+        except ImportError:
+            missing.append(pkg)
+    if missing:
+        print(f"[build] Missing packages: {missing}")
+        print(f"[build] Run: pip install {' '.join(missing)}")
+        sys.exit(1)
+
+
+def _create_placeholder_icon() -> None:
+    """Create a minimal valid .ico if none exists."""
+    if ICON.exists():
+        return
+    ICON.parent.mkdir(parents=True, exist_ok=True)
+    # 1x1 px ICO (minimal valid format)
+    ico_bytes = bytes([
+        0,0,1,0,1,0,1,1,0,0,1,0,32,0,40,0,0,0,22,0,0,0,40,0,0,0,
+        1,0,0,0,2,0,0,0,1,0,32,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,30,89,159,255,0,0,0,0,
+    ])
+    ICON.write_bytes(ico_bytes)
+    print(f"[build] Created placeholder icon at {ICON}")
+
+
+def _write_spec() -> None:
+    ps6 = _pyside6_path()
+    qml_src = str(ps6 / "qml").replace("\\", "/")
+    app_qml  = str(ROOT / "frontend").replace("\\", "/")
+    assets   = str(ROOT / "assets").replace("\\", "/")
+
+    spec = f"""# -*- mode: python ; coding: utf-8 -*-
+import sys
+from pathlib import Path
+from PyInstaller.utils.hooks import collect_all, collect_data_files
+
+# Collect PySide6 properly
+pyside6_datas, pyside6_binaries, pyside6_hiddenimports = collect_all('PySide6')
+
+block_cipher = None
+
+a = Analysis(
+    ['{str(ROOT / "main.py").replace(chr(92), "/")}'],
+    pathex=['{str(ROOT).replace(chr(92), "/")}'],
+    binaries=pyside6_binaries,
+    datas=[
+        ('{app_qml}',  'frontend'),
+        ('{assets}',   'assets'),
+        ('{qml_src}',  'PySide6/qml'),
+        *pyside6_datas,
+    ],
+    hiddenimports=[
+        *pyside6_hiddenimports,
+        'PySide6.QtQml',
+        'PySide6.QtQuick',
+        'PySide6.QtQuickControls2',
+        'PySide6.QtCore',
+        'PySide6.QtWidgets',
+        'PySide6.QtGui',
+        'PySide6.QtNetwork',
+        'PySide6.QtMultimedia',
+        'uvicorn',
+        'uvicorn.logging',
+        'uvicorn.loops',
+        'uvicorn.loops.auto',
+        'uvicorn.loops.asyncio',
+        'uvicorn.protocols',
+        'uvicorn.protocols.http',
+        'uvicorn.protocols.http.auto',
+        'uvicorn.protocols.http.h11_impl',
+        'uvicorn.protocols.websockets',
+        'uvicorn.protocols.websockets.auto',
+        'uvicorn.lifespan',
+        'uvicorn.lifespan.on',
+        'fastapi',
+        'sqlalchemy',
+        'sqlalchemy.dialects.sqlite',
+        'sqlalchemy.orm',
+        'aiofiles',
+        'backend',
+        'backend.api',
+        'backend.api.routers',
+        'backend.db',
+        'backend.services',
+        'backend.models',
+    ],
+    hookspath=[],
+    hooksconfig={{}},
+    runtime_hooks=[],
+    excludes=['tkinter', 'matplotlib', 'PIL'],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz, a.scripts, [],
+    exclude_binaries=True,
+    name='AegisScoreStudio',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=['Qt6*.dll', 'python3*.dll'],
+    console=False,
+    disable_windowed_traceback=False,
+    icon='{str(ICON).replace(chr(92), "/")}',
+)
+
+coll = COLLECT(
+    exe, a.binaries, a.zipfiles, a.datas,
+    strip=False,
+    upx=True,
+    upx_exclude=['Qt6*.dll', 'python3*.dll'],
+    name='AegisScoreStudio',
+)
+"""
+    SPEC_FILE.write_text(spec, encoding="utf-8")
+    print(f"[build] Wrote {SPEC_FILE.name}")
+
+
+def _run_pyinstaller() -> None:
+    cmd = [
+        sys.executable, "-m", "PyInstaller",
+        "--clean",
+        "--noconfirm",
+        str(SPEC_FILE),
+    ]
+    print("[build] Running PyInstaller…")
+    subprocess.check_call(cmd, cwd=ROOT)
+
+
+def _write_launcher_bat() -> None:
+    """Convenience launcher next to the exe."""
+    bat = OUT_DIR / "Launch Aegis Score Studio.bat"
+    bat.write_text(
+        '@echo off\r\nstart "" "%~dp0AegisScoreStudio.exe"\r\n',
+        encoding="utf-8"
+    )
+
+
+def _write_readme() -> None:
+    readme = OUT_DIR / "README.txt"
+    readme.write_text(
+        "Aegis Score Studio\n"
+        "==================\n"
+        "Run AegisScoreStudio.exe to start.\n\n"
+        "Requirements:\n"
+        "  - ffmpeg.exe must be on PATH or placed in this folder.\n"
+        "  - Internet connection for YouTube download.\n"
+        "  - GPU optional; CPU fallback available.\n\n"
+        "First run downloads Demucs model weights (~800 MB).\n",
+        encoding="utf-8"
+    )
+
+
+def _zip_output() -> None:
+    print(f"[build] Zipping {OUT_DIR} → {OUT_ZIP}")
+    with zipfile.ZipFile(OUT_ZIP, "w", zipfile.ZIP_DEFLATED, compresslevel=6) as zf:
+        for f in OUT_DIR.rglob("*"):
+            if f.is_file():
+                zf.write(f, f.relative_to(DIST_DIR))
+    size_mb = OUT_ZIP.stat().st_size / 1_000_000
+    print(f"[build] ZIP created: {OUT_ZIP} ({size_mb:.0f} MB)")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build Aegis Score Studio portable exe")
+    parser.add_argument("--zip",            action="store_true", help="Create ZIP archive of dist folder")
+    parser.add_argument("--skip-deps-check",action="store_true", help="Skip dependency check")
+    args = parser.parse_args()
+
+    if not args.skip_deps_check:
+        _check_deps()
+
+    _create_placeholder_icon()
+    _write_spec()
+    _run_pyinstaller()
+    _write_launcher_bat()
+    _write_readme()
+
+    print(f"\n[build] ✓ Done → {OUT_DIR}")
+    print(f"[build]   Exe:  {OUT_DIR / 'AegisScoreStudio.exe'}")
+    size_mb = sum(f.stat().st_size for f in OUT_DIR.rglob("*") if f.is_file()) / 1_000_000
+    print(f"[build]   Size: {size_mb:.0f} MB")
+
+    if args.zip:
+        _zip_output()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/server.py b/server.py
index 21f037c..d5aa723 100644
--- a/server.py
+++ b/server.py
@@ -3,23 +3,57 @@
 Run: uvicorn server:app --port 7471 --reload
 """
 from __future__ import annotations
-import asyncio, uuid, shutil, sys, os
+import asyncio, uuid, shutil, sys, os, time, traceback, threading, math
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
+# Store all AI model weights in models/ next to server.py (visible, portable)
+_MODELS_DIR = Path(__file__).parent / "models"
+_MODELS_DIR.mkdir(exist_ok=True)
+os.environ.setdefault("TORCH_HOME", str(_MODELS_DIR))
+
+def _bg_update_ytdlp():
+    """Silently update yt-dlp in background on startup — YouTube API changes frequently."""
+    try:
+        import subprocess
+        subprocess.run([sys.executable, "-m", "pip", "install", "-U", "yt-dlp", "-q"],
+                       capture_output=True, timeout=120)
+    except Exception:
+        pass
+
+threading.Thread(target=_bg_update_ytdlp, daemon=True).start()
+
 from fastapi import FastAPI, BackgroundTasks, HTTPException, UploadFile, File
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
 app = FastAPI(title="AegisScore")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-WORK_DIR = Path("work")
-WORK_DIR.mkdir(exist_ok=True)
+WORK_DIR = Path(os.environ.get("AEGIS_WORK_DIR", "work"))
+WORK_DIR.mkdir(exist_ok=True, parents=True)
 
 URL_CACHE: dict[str, str] = {}   # url → sid
 JOBS: dict[str, dict] = {}
 
+# Rebuild URL_CACHE from persisted sessions on startup
+def _rebuild_cache():
+    import json as _json
+    for sf in WORK_DIR.glob("*/session.json"):
+        try:
+            j = _json.loads(sf.read_text(encoding="utf-8"))
+            if j.get("status") == "done":
+                src = j.get("meta", {}).get("source", "")
+                if src.startswith("http"):
+                    URL_CACHE[src] = sf.parent.name
+                JOBS[sf.parent.name] = j
+        except Exception:
+            pass
+
+_rebuild_cache()
+
 DEMUCS_SOURCES = ["drums", "bass", "other", "vocals", "guitar", "piano"]
 
 STEM_META = {
@@ -31,6 +65,73 @@
     "other":  {"name": "Other",  "instrument": "Mixed / Other",          "family": "Synth",             "clef": "treble", "color": "--s-synth",  "role": "Texture"},
 }
 
+
+def _classify_stem_sync(stem_name: str, wav_path: Path, midi_path: Path) -> dict:
+    """Detect silence, classify 'other' stem, set clef from actual MIDI pitch range."""
+    import librosa, numpy as np
+    SR = 22050
+
+    base = dict(STEM_META.get(stem_name, {}))  # start from defaults
+
+    try:
+        y, _ = librosa.load(str(wav_path), sr=SR, mono=True, duration=60)
+        rms = float(np.sqrt(np.mean(y ** 2)))
+
+        # Silence — stem physically absent / near-zero
+        if rms < 0.0015:
+            base["removed"] = True
+            return base
+        base["removed"] = False
+
+        # ── Clef from actual MIDI pitch range (beats hardcoded clef) ──────────
+        if stem_name != "drums" and midi_path.exists():
+            try:
+                import pretty_midi
+                pm = pretty_midi.PrettyMIDI(str(midi_path))
+                pitches = [n.pitch for inst in pm.instruments for n in inst.notes]
+                if pitches:
+                    median_p = float(np.median(pitches))
+                    base["clef"] = "bass" if median_p < 52 else "treble"
+            except Exception:
+                pass
+
+        # ── "other" stem: identify from spectral features ─────────────────────
+        if stem_name == "other":
+            centroid  = float(np.mean(librosa.feature.spectral_centroid(y=y, sr=SR)))
+            bandwidth = float(np.mean(librosa.feature.spectral_bandwidth(y=y, sr=SR)))
+            zcr       = float(np.mean(librosa.feature.zero_crossing_rate(y)))
+            y_harm    = librosa.effects.harmonic(y=y)
+            harmonic  = float(np.mean(y_harm ** 2)) / max(1e-9, float(np.mean(y ** 2)))
+
+            if centroid < 400:
+                base.update({"name": "Cello",        "instrument": "Cello",         "family": "Low Strings · GM 42", "clef": "bass",   "color": "--s-bass",   "role": "Low end"})
+            elif centroid < 900 and harmonic > 0.4:
+                base.update({"name": "Viola",        "instrument": "Viola",         "family": "Strings · GM 41",     "clef": "treble", "color": "--s-synth",  "role": "Harmony"})
+            elif centroid < 1800 and harmonic > 0.5:
+                base.update({"name": "Strings",      "instrument": "String Ensemble","family": "Strings · GM 48",    "clef": "treble", "color": "--s-synth",  "role": "Texture"})
+            elif centroid < 1600 and zcr < 0.04:
+                base.update({"name": "Pad",          "instrument": "Synth Pad",     "family": "Pad · GM 88",         "clef": "treble", "color": "--s-synth",  "role": "Texture"})
+            elif centroid < 2400 and harmonic > 0.35:
+                base.update({"name": "Brass",        "instrument": "Brass Section", "family": "Brass · GM 61",       "clef": "treble", "color": "--s-synth",  "role": "Harmony"})
+            elif centroid > 3500 and zcr < 0.06:
+                base.update({"name": "Flute",        "instrument": "Flute",         "family": "Woodwind · GM 73",    "clef": "treble", "color": "--s-synth",  "role": "Melody"})
+            elif zcr > 0.10:
+                base.update({"name": "Synth Lead",   "instrument": "Synth Lead",    "family": "Synth · GM 80",       "clef": "treble", "color": "--s-synth",  "role": "Texture"})
+            else:
+                base.update({"name": "Keys / Other", "instrument": "Electric Piano","family": "Keys · GM 4",         "clef": "treble", "color": "--s-keys",   "role": "Texture"})
+
+        # ── Acoustic guitar vs electric heuristic ─────────────────────────────
+        elif stem_name == "guitar":
+            centroid = float(np.mean(librosa.feature.spectral_centroid(y=y, sr=SR)))
+            zcr      = float(np.mean(librosa.feature.zero_crossing_rate(y)))
+            if centroid < 1200 and zcr < 0.05:
+                base.update({"name": "Acoustic Guitar", "instrument": "Acoustic Guitar", "family": "Guitar · GM 25"})
+
+    except Exception:
+        pass
+
+    return base
+
 # ThreadPoolExecutor — safe on Windows (no spawn/pickle issues unlike ProcessPool)
 _POOL = ThreadPoolExecutor(max_workers=min(6, (os.cpu_count() or 2)))
 
@@ -38,11 +139,21 @@
 # ── Models ────────────────────────────────────────────────────────────────────
 class AnalyzeRequest(BaseModel):
     url: str
+    force: bool = False
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
 def _set(sid: str, **kwargs):
     JOBS[sid].update(kwargs)
+    # Persist completed/failed jobs to disk so they survive a server restart
+    if kwargs.get("status") in ("done", "error"):
+        try:
+            import json as _json
+            (WORK_DIR / sid / "session.json").write_text(
+                _json.dumps(JOBS[sid], default=str), encoding="utf-8"
+            )
+        except Exception:
+            pass
 
 
 async def _run_async(cmd: list[str]) -> None:
@@ -57,57 +168,202 @@ async def _run_async(cmd: list[str]) -> None:
         raise RuntimeError(f"Command failed (exit {proc.returncode}):\n{detail}")
 
 
-def _transcribe_stem_sync(wav_path: Path, midi_out: Path, is_drums: bool) -> int:
-    """Runs in thread pool. Returns note count."""
+# GM program per stem for correct MuseScore instrument assignment
+_STEM_PROGRAM = {
+    "bass":   33,  # Electric Bass (finger)
+    "guitar": 25,  # Acoustic Guitar (nylon) — overridden to 27 (clean electric) if classified
+    "piano":  0,   # Acoustic Grand Piano
+    "vocals": 52,  # Choir Aahs
+    "other":  48,  # String Ensemble 1
+}
+
+
+def _transcribe_stem_sync(wav_path: Path, midi_out: Path, is_drums: bool, tempo: float = 120.0) -> tuple:
+    """Runs in thread pool. Returns (note_count, confidence_pct)."""
     import librosa
     import numpy as np
     import pretty_midi
 
+    job_dir = wav_path.parent.parent
     SR = 22050
-    HOP = 1024
-    y, sr = librosa.load(str(wav_path), sr=SR, mono=True, duration=300)
-    pm = pretty_midi.PrettyMIDI()
+    HOP = 2048
+    stem_name = wav_path.stem
+    _log(job_dir, f"--- MIDI TRANSCRIPTION: {stem_name} ---")
 
     if is_drums:
-        drum = pretty_midi.Instrument(program=0, is_drum=True)
+        y, sr = librosa.load(str(wav_path), sr=SR, mono=True, duration=300)
+        pm = pretty_midi.PrettyMIDI(initial_tempo=float(tempo))
+        drum = pretty_midi.Instrument(program=0, is_drum=True, name="Drums")
         onset_frames = librosa.onset.onset_detect(y=y, sr=sr, units="frames",
                                                    backtrack=True, hop_length=HOP)
         onset_times = librosa.frames_to_time(onset_frames, sr=sr, hop_length=HOP)
         for i, t in enumerate(onset_times):
             drum.notes.append(pretty_midi.Note(velocity=90,
-                pitch=36 if i % 2 == 0 else 38, start=float(t), end=float(t) + 0.05))
+                pitch=36 if i % 2 == 0 else 38, start=float(t), end=float(t) + 0.12))
         pm.instruments.append(drum)
         pm.write(str(midi_out))
-        return len(drum.notes)
-
-    f0, voiced_flag, _ = librosa.pyin(y, fmin=librosa.note_to_hz("C2"),
-                                       fmax=librosa.note_to_hz("C7"),
-                                       sr=sr, frame_length=2048, hop_length=HOP)
-    times = librosa.times_like(f0, sr=sr, hop_length=HOP)
-
-    instrument = pretty_midi.Instrument(program=0)
-    in_note = False
-    note_start = 0.0
-    note_pitch = 0
-    for t, freq, voiced in zip(times, f0, voiced_flag):
-        if voiced and not np.isnan(freq):
-            mp = max(0, min(127, int(round(librosa.hz_to_midi(freq)))))
-            if not in_note:
-                in_note, note_start, note_pitch = True, float(t), mp
-            elif mp != note_pitch:
-                if float(t) - note_start >= 0.05:
-                    instrument.notes.append(pretty_midi.Note(velocity=80, pitch=note_pitch,
-                                                              start=note_start, end=float(t)))
-                note_start, note_pitch = float(t), mp
-        elif in_note:
-            if float(t) - note_start >= 0.05:
-                instrument.notes.append(pretty_midi.Note(velocity=80, pitch=note_pitch,
-                                                          start=note_start, end=float(t)))
-            in_note = False
-
-    pm.instruments.append(instrument)
+        _log(job_dir, f"  method:     onset_detect (drums)",
+                      f"  onsets:     {len(onset_frames)}",
+                      f"  notes_out:  {len(drum.notes)}")
+        return len(drum.notes), 70.0
+
+    if "bass" in stem_name:
+        fmin, fmax = librosa.note_to_hz("C1"), librosa.note_to_hz("C5")
+        fmin_name, fmax_name = "C1", "C5"
+    elif "guitar" in stem_name:
+        fmin, fmax = librosa.note_to_hz("E2"), librosa.note_to_hz("E7")
+        fmin_name, fmax_name = "E2", "E7"
+    else:
+        fmin, fmax = librosa.note_to_hz("C2"), librosa.note_to_hz("C7")
+        fmin_name, fmax_name = "C2", "C7"
+
+    # omnizart: multi-instrument neural transcription — best for orchestral/ensemble audio
+    if stem_name == "other" and _OMNIZART_AVAIL:
+        try:
+            import subprocess as _sp
+            _log(job_dir, f"  method:     omnizart (multi-instrument)")
+            # CLI: omnizart music transcribe <wav> -o <outdir>
+            # outputs <outdir>/<wav_stem>.mid — matches midi_out path exactly
+            _proc = _sp.run(
+                [_OMNIZART_PYTHON, "-m", "omnizart", "music", "transcribe",
+                 str(wav_path), "-o", str(midi_out.parent)],
+                capture_output=True, timeout=900
+            )
+            if _proc.returncode == 0 and midi_out.exists():
+                import pretty_midi as _pm_omni
+                _pm_check = _pm_omni.PrettyMIDI(str(midi_out))
+                note_count = sum(len(i.notes) for i in _pm_check.instruments)
+                _log(job_dir,
+                     f"  notes_out:  {note_count}",
+                     f"  tracks:     {len(_pm_check.instruments)}",
+                     *[f"    [{i.program:3d}] {i.name or 'unnamed'}: {len(i.notes)} notes"
+                       for i in _pm_check.instruments])
+                return note_count, 88.0
+            else:
+                _log(job_dir,
+                     f"  omnizart exit {_proc.returncode} — falling back",
+                     _proc.stderr.decode(errors="replace")[-400:])
+        except Exception as exc:
+            _log(job_dir, f"  omnizart error: {exc} — falling back to basic-pitch")
+
+    # basic-pitch: polyphonic neural transcription (best quality, requires pip install basic-pitch)
+    if _BASIC_PITCH_AVAIL:
+        try:
+            from basic_pitch.inference import predict as _bp_predict
+            _log(job_dir, f"  method:     basic-pitch  fmin={fmin_name} fmax={fmax_name}")
+            model_arg = _BP_MODEL if _BP_MODEL is not None else None
+            predict_kwargs = dict(
+                minimum_note_length=150.0,
+                minimum_frequency=fmin,
+                maximum_frequency=fmax,
+                onset_threshold=0.5,
+                frame_threshold=0.35,
+                melodia_trick=True,
+            )
+            if model_arg is not None:
+                model_out, midi_data, _ = _bp_predict(str(wav_path), model_arg, **predict_kwargs)
+            else:
+                model_out, midi_data, _ = _bp_predict(str(wav_path), **predict_kwargs)
+            # Rewrite with correct tempo + instrument program so MuseScore imports cleanly
+            pm_out = pretty_midi.PrettyMIDI(initial_tempo=float(tempo))
+            prog = _STEM_PROGRAM.get(stem_name, 0)
+            for inst in midi_data.instruments:
+                if not inst.is_drum:
+                    inst.program = prog
+                    inst.name = stem_name.title()
+            pm_out.instruments = midi_data.instruments
+            pm_out.write(str(midi_out))
+            note_count = sum(len(inst.notes) for inst in pm_out.instruments)
+            note_probs = model_out.get("note")
+            if note_probs is not None and note_probs.size > 0:
+                conf = float(np.mean(np.max(note_probs, axis=-1))) * 100.0
+            else:
+                conf = 50.0
+            _log(job_dir, f"  notes_out:  {note_count}", f"  confidence: {conf:.1f}%")
+            return note_count, round(conf, 1)
+        except Exception as exc:
+            _log(job_dir, f"  basic-pitch error: {exc} — falling back to CQT")
+
+    # CQT-based polyphonic transcription — works on separated orchestral stems, no extra deps
+    _log(job_dir, f"  method:     CQT-poly  fmin={fmin_name} ({fmin:.1f} Hz)  fmax={fmax_name} ({fmax:.1f} Hz)")
+    y, sr = librosa.load(str(wav_path), sr=SR, mono=True, duration=300)
+
+    fmin_midi = max(0, int(round(librosa.hz_to_midi(fmin))))
+    fmax_midi = min(127, int(round(librosa.hz_to_midi(fmax))))
+    n_bins = max(1, fmax_midi - fmin_midi)
+    fmin_hz = float(librosa.midi_to_hz(fmin_midi))
+
+    C = np.abs(librosa.cqt(y, sr=sr, hop_length=HOP,
+                            n_bins=n_bins, bins_per_octave=12, fmin=fmin_hz))
+
+    flat = C.ravel()
+    if flat.max() < 1e-7:
+        _log(job_dir, "  WARNING: silent stem")
+        pm = pretty_midi.PrettyMIDI(initial_tempo=float(tempo))
+        pm.instruments.append(pretty_midi.Instrument(program=_STEM_PROGRAM.get(stem_name, 0), name=stem_name.title()))
+        pm.write(str(midi_out))
+        return 0, 0.0
+
+    # Per-frame max energy; global floor at 75th percentile of nonzero values
+    frame_max = C.max(axis=0)
+    global_floor = float(np.percentile(flat[flat > 0], 75))
+
+    times = librosa.frames_to_time(np.arange(C.shape[1]), sr=sr, hop_length=HOP)
+    MAX_POLY = 3 if "bass" in stem_name else 5  # bass usually monophonic/duophonic
+    MIN_DUR  = 0.08
+
+    pm = pretty_midi.PrettyMIDI(initial_tempo=float(tempo))
+    inst = pretty_midi.Instrument(program=_STEM_PROGRAM.get(stem_name, 0), name=stem_name.title())
+    active: dict[int, float] = {}  # midi_pitch -> start_time
+
+    for fi in range(C.shape[1]):
+        t = float(times[fi])
+        col = C[:, fi]
+        col_max = float(frame_max[fi])
+
+        if col_max < global_floor * 0.2:
+            # Silent frame — close all open notes
+            for mp, s in list(active.items()):
+                if t - s >= MIN_DUR:
+                    inst.notes.append(pretty_midi.Note(70, mp, s, t))
+            active.clear()
+            continue
+
+        # Find pitches above 45 % of this frame's peak AND above global floor
+        col_norm = col / col_max
+        cands = np.where((col_norm > 0.45) & (col > global_floor * 0.3))[0]
+        if len(cands) > MAX_POLY:
+            cands = cands[np.argsort(col[cands])[-MAX_POLY:]]
+        on_now = set(int(fmin_midi + b) for b in cands if fmin_midi + int(b) <= 127)
+
+        # Close notes that stopped
+        for mp in list(active.keys()):
+            if mp not in on_now:
+                s = active.pop(mp)
+                if t - s >= MIN_DUR:
+                    inst.notes.append(pretty_midi.Note(70, mp, s, t))
+        # Open new notes
+        for mp in on_now:
+            if mp not in active:
+                active[mp] = t
+
+    # Close remaining open notes at end of file
+    end_t = float(times[-1])
+    for mp, s in active.items():
+        if end_t - s >= MIN_DUR:
+            inst.notes.append(pretty_midi.Note(70, mp, s, end_t))
+
+    pm.instruments.append(inst)
     pm.write(str(midi_out))
-    return len(instrument.notes)
+    n_notes = len(inst.notes)
+
+    loud_frames = int(np.sum(frame_max >= global_floor * 0.2))
+    conf = float(loud_frames / max(1, C.shape[1])) * 100.0
+    _log(job_dir,
+         f"  notes_out:  {n_notes}",
+         f"  loud_frames:{loud_frames}/{C.shape[1]} ({conf:.1f}%)",
+         f"  cqt_bins:   {n_bins}")
+    return n_notes, round(conf, 1)
 
 
 def _gpu_info() -> dict:
@@ -124,6 +380,172 @@ def _gpu_info() -> dict:
 
 _DEVICE = "cuda" if __import__("torch").cuda.is_available() else "cpu"
 
+try:
+    import logging as _lg; _rl = _lg.getLogger(); _prev = _rl.level; _rl.setLevel(_lg.ERROR)
+    import basic_pitch  # noqa: F401
+    _BASIC_PITCH_AVAIL = True
+    _rl.setLevel(_prev)
+except ImportError:
+    _BASIC_PITCH_AVAIL = False
+
+# omnizart requires Python ≤ 3.9 — may live in a separate venv.
+# Point OMNIZART_PYTHON at that venv's python.exe to enable it.
+_OMNIZART_PYTHON = os.environ.get("OMNIZART_PYTHON", sys.executable)
+try:
+    import subprocess as _sp_omni_check
+    _r = _sp_omni_check.run(
+        [_OMNIZART_PYTHON, "-c", "import omnizart"],
+        capture_output=True, timeout=15)
+    _OMNIZART_AVAIL = (_r.returncode == 0)
+except Exception:
+    _OMNIZART_AVAIL = False
+
+# Preload basic-pitch ONNX model once at startup — avoids 5× reload per session
+_BP_MODEL = None
+if _BASIC_PITCH_AVAIL:
+    try:
+        import logging as _lg2; _rl2 = _lg2.getLogger(); _p2 = _rl2.level; _rl2.setLevel(_lg2.ERROR)
+        from basic_pitch import ICASSP_2022_MODEL_PATH
+        from basic_pitch.inference import Model as _BPModel
+        _BP_MODEL = _BPModel(ICASSP_2022_MODEL_PATH)
+        _rl2.setLevel(_p2)
+    except Exception:
+        pass
+
+
+# ── Debug logger ──────────────────────────────────────────────────────────────
+def _log(job_dir: Path, *lines: str):
+    """Append timestamped lines to work/{sid}/debug.log."""
+    log_path = job_dir / "debug.log"
+    ts = time.strftime("%Y-%m-%d %H:%M:%S")
+    with open(log_path, "a", encoding="utf-8") as f:
+        for line in lines:
+            f.write(f"[{ts}] {line}\n")
+
+
+def _analyze_audio_sync(wav_path: Path, job_dir: Path) -> dict:
+    """Detect BPM, key, time sig, sample rate, bit depth. Runs in thread pool."""
+    import librosa, numpy as np, soundfile as sf
+
+    _log(job_dir, "=== AUDIO ANALYSIS ===", f"file: {wav_path.name}")
+
+    info = sf.info(str(wav_path))
+    sample_rate = info.samplerate
+    bit_depth = {"PCM_16": 16, "PCM_24": 24, "PCM_32": 32, "FLOAT": 32}.get(info.subtype, 16)
+    _log(job_dir,
+         f"format:      {info.subtype} ({bit_depth}-bit)",
+         f"sample_rate: {sample_rate} Hz",
+         f"duration:    {info.duration:.2f} s  ({info.duration/60:.1f} min)",
+         f"channels:    {info.channels}")
+
+    SR = 22050
+    y, _ = librosa.load(str(wav_path), sr=SR, mono=True, duration=180)
+
+    # Tempo + time sig — beat_this (ISMIR 2024) → madmom → librosa
+    beat_frames = np.array([])
+    tempo = 120
+    time_sig = [4, 4]
+    _beat_method = "?"
+
+    try:
+        from beat_this.inference import File2Beats
+        _log(job_dir, "tempo_method: beat_this (ISMIR 2024)")
+        f2b = File2Beats(checkpoint_path="final0", device=_DEVICE, dbn=False)
+        _bt_beats, _bt_db = f2b(str(wav_path))
+        beat_times = np.array(_bt_beats, dtype=float)
+        db_arr    = np.array(_bt_db,    dtype=float)
+        if len(beat_times) >= 4:
+            intervals = np.diff(beat_times)
+            med = float(np.median(intervals))
+            tempo = max(40, min(250, int(round(60.0 / med if med > 0 else 120.0))))
+            beat_frames = librosa.time_to_frames(beat_times, sr=SR)
+        if len(db_arr) >= 3:
+            bpb_list = []
+            for k in range(len(db_arr) - 1):
+                n = int(np.sum((beat_times >= db_arr[k]) & (beat_times < db_arr[k+1])))
+                if 2 <= n <= 8:
+                    bpb_list.append(n)
+            if bpb_list:
+                bpb = int(round(float(np.median(bpb_list))))
+                time_sig = [bpb if bpb in (3, 4, 5, 6, 7) else 4, 4]
+        _beat_method = "beat_this"
+        _log(job_dir,
+             f"tempo:       {tempo} BPM",
+             f"beats:       {len(beat_times)}  downbeats: {len(db_arr)}",
+             f"time_sig:    {time_sig[0]}/{time_sig[1]}  (from downbeats)")
+    except Exception as exc:
+        _log(job_dir, f"beat_this failed ({exc}), trying madmom")
+        try:
+            import madmom
+            from madmom.features.beats import RNNBeatProcessor, BeatTrackingProcessor
+            _log(job_dir, "tempo_method: madmom RNNBeatProcessor")
+            proc = RNNBeatProcessor()(str(wav_path))
+            beat_times = BeatTrackingProcessor(fps=100)(proc)
+            if len(beat_times) >= 4:
+                intervals = np.diff(beat_times)
+                med = float(np.median(intervals))
+                tempo = max(40, min(250, int(round(60.0 / med if med > 0 else 120.0))))
+                beat_frames = librosa.time_to_frames(beat_times, sr=SR)
+            _beat_method = "madmom"
+            _log(job_dir, f"tempo:       {tempo} BPM  beats: {len(beat_times)}")
+        except Exception as exc2:
+            _log(job_dir, f"madmom failed ({exc2}), using librosa")
+            tempo_raw, beat_frames = librosa.beat.beat_track(y=y, sr=SR)
+            tempo = max(40, min(250, int(round(float(tempo_raw)))))
+            _beat_method = "librosa"
+            _log(job_dir, f"tempo:       {tempo} BPM  (librosa)")
+
+    # Time sig autocorrelation fallback (when beat_this didn't set it via downbeats)
+    if _beat_method != "beat_this" and len(beat_frames) >= 8:
+        try:
+            oenv = librosa.onset.onset_strength(y=y, sr=SR)
+            bf = beat_frames[beat_frames < len(oenv)]
+            strengths = oenv[bf] - oenv[bf].mean()
+            ac = np.correlate(strengths, strengths, mode='full')[len(strengths) - 1:]
+            if len(ac) > 4:
+                ac3, ac4 = float(ac[3]), float(ac[4])
+                if ac3 > ac4 * 1.15:
+                    time_sig = [3, 4]
+            _log(job_dir, f"time_sig:    {time_sig[0]}/{time_sig[1]}  (autocorrelation)")
+        except Exception as exc:
+            _log(job_dir, f"time_sig_error: {exc}")
+
+    # Key — Krumhansl-Schmuckler over CQT chroma
+    major_prof = np.array([6.35,2.23,3.48,2.33,4.38,4.09,2.52,5.19,2.39,3.66,2.29,2.88])
+    minor_prof = np.array([6.33,2.68,3.52,5.38,2.60,3.53,2.54,4.75,3.98,2.69,3.34,3.17])
+    chroma = librosa.feature.chroma_cqt(y=y, sr=SR).mean(axis=1)
+    note_names = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
+    best_key, best_r = "C major", -2.0
+    all_scores: list[tuple[float, str]] = []
+    for i in range(12):
+        r_maj = float(np.corrcoef(chroma, np.roll(major_prof, i))[0, 1])
+        r_min = float(np.corrcoef(chroma, np.roll(minor_prof, i))[0, 1])
+        all_scores.append((r_maj, f"{note_names[i]} major"))
+        all_scores.append((r_min, f"{note_names[i]} minor"))
+        if r_maj > best_r: best_r, best_key = r_maj, f"{note_names[i]} major"
+        if r_min > best_r: best_r, best_key = r_min, f"{note_names[i]} minor"
+    top5 = sorted(all_scores, reverse=True)[:5]
+    _log(job_dir, f"key_detected: {best_key}  (r={best_r:.4f})")
+    for r, k in top5:
+        _log(job_dir, f"  {r:+.4f}  {k}{' <-- CHOSEN' if k == best_key else ''}")
+
+    # Spectrum — 40 log-spaced energy bins for UI visualizer (0–100 scale)
+    spectrum: list[float] = []
+    try:
+        S = np.abs(librosa.stft(y, n_fft=2048, hop_length=512))
+        freq_energy = np.log1p(S.mean(axis=1))
+        if freq_energy.max() > 0:
+            freq_energy = freq_energy / freq_energy.max() * 100.0
+        indices = np.linspace(0, len(freq_energy) - 1, 40)
+        spectrum = [float(max(0.0, min(100.0, np.interp(ix, np.arange(len(freq_energy)), freq_energy))))
+                    for ix in indices]
+    except Exception:
+        pass
+
+    _log(job_dir, "=== ANALYSIS DONE ===")
+    return {"tempo": tempo, "key": best_key, "timeSig": time_sig,
+            "sampleRate": sample_rate, "bitDepth": bit_depth, "spectrum": spectrum}
+
 
 # ── Shared separation + transcription logic ────────────────────────────────────
 async def _separate_and_transcribe(sid: str, audio_path: Path, meta: dict):
@@ -133,66 +555,553 @@ async def _separate_and_transcribe(sid: str, audio_path: Path, meta: dict):
     stems_dir.mkdir(exist_ok=True)
     midi_dir.mkdir(exist_ok=True)
 
-    # Stage 1: Demucs
+    # Stage 1: Demucs + audio analysis in parallel
     _set(sid, stage=1, status="separating", progress=0.20)
+    _log(job_dir, "=== SEPARATION ===", f"device: {_DEVICE}", f"model:  htdemucs_6s")
     py = sys.executable
-    await _run_async([py, "-m", "demucs",
-                      "--name", "htdemucs_6s",
-                      "--device", _DEVICE,
-                      "--out", str(job_dir / "demucs_out"),
-                      str(audio_path)])
+    loop = asyncio.get_running_loop()
+    analysis_fut = loop.run_in_executor(_POOL, _analyze_audio_sync, audio_path, job_dir)
+
+    # Smooth progress 20%→60% while demucs runs (subprocess gives no callbacks)
+    # htdemucs_6s: CPU ~3.5× realtime, GPU ~0.7× realtime
+    _dur = meta.get("duration", 120)
+    _est = max(30.0, _dur * (0.8 if _DEVICE == "cuda" else 3.5))
+    async def _sep_progress():
+        _t0 = time.time()
+        while True:
+            _frac = min(0.97, 1.0 - math.exp(-2.5 * (time.time() - _t0) / _est))
+            _set(sid, progress=0.20 + _frac * 0.40)
+            await asyncio.sleep(2)
+    _prog_task = asyncio.create_task(_sep_progress())
+    try:
+        await _run_async([py, "-m", "demucs",
+                          "--name", "htdemucs_6s",
+                          "--device", _DEVICE,
+                          "--out", str(job_dir / "demucs_out"),
+                          str(audio_path)])
+    finally:
+        _prog_task.cancel()
+        try: await _prog_task
+        except asyncio.CancelledError: pass
+
     demucs_root = next((job_dir / "demucs_out" / "htdemucs_6s").iterdir())
+    stem_sizes = {}
     for stem_wav in demucs_root.glob("*.wav"):
         shutil.copy(stem_wav, stems_dir / stem_wav.name)
+        stem_sizes[stem_wav.stem] = stem_wav.stat().st_size
+    analysis = await analysis_fut
+    _log(job_dir, "stems_separated:",
+         *[f"  {k}: {v/1024:.0f} KB" for k, v in sorted(stem_sizes.items())])
     _set(sid, progress=0.62)
 
     # Stage 2: Instrument ID
     _set(sid, stage=2, status="identifying", progress=0.64)
     _set(sid, progress=0.70)
 
-    # Stage 3: MIDI — parallel threads
+    # Stage 3: MIDI — sequential (ONNX not safe for concurrent CPU inference)
     _set(sid, stage=3, status="transcribing", progress=0.72)
-    loop = asyncio.get_event_loop()
-    tasks, stem_names = [], []
-    for stem_name in DEMUCS_SOURCES:
-        stem_file = stems_dir / f"{stem_name}.wav"
-        if not stem_file.exists():
-            continue
-        tasks.append(loop.run_in_executor(
-            _POOL, _transcribe_stem_sync,
-            stem_file, midi_dir / f"{stem_name}.mid", stem_name == "drums"))
-        stem_names.append(stem_name)
+    stem_queue = [(n, stems_dir / f"{n}.wav") for n in DEMUCS_SOURCES
+                  if (stems_dir / f"{n}.wav").exists()]
+    midi_counts, midi_confs = {}, {}
+    _n_stems = max(len(stem_queue), 1)
+    for i, (stem_name, stem_file) in enumerate(stem_queue):
+        try:
+            r = await loop.run_in_executor(
+                _POOL, _transcribe_stem_sync,
+                stem_file, midi_dir / f"{stem_name}.mid", stem_name == "drums",
+                float(analysis.get("tempo", 120)))
+            if isinstance(r, tuple):
+                midi_counts[stem_name], midi_confs[stem_name] = r[0], r[1]
+            else:
+                midi_counts[stem_name] = int(r); midi_confs[stem_name] = 90.0
+        except Exception as exc:
+            midi_counts[stem_name] = 0; midi_confs[stem_name] = 0.0
+            _log(job_dir, f"MIDI_ERROR [{stem_name}]: {exc}")
+        _set(sid, progress=0.72 + (i + 1) / _n_stems * 0.18)
 
-    results = await asyncio.gather(*tasks, return_exceptions=True)
-    midi_counts = {n: (r if isinstance(r, int) else 0) for n, r in zip(stem_names, results)}
-    _set(sid, progress=0.90)
+    # Dynamic classification — silence filter + instrument ID
+    stem_classifications: dict[str, dict] = {}
+    for stem_name, stem_file in stem_queue:
+        try:
+            cls = await loop.run_in_executor(
+                _POOL, _classify_stem_sync,
+                stem_name, stem_file, midi_dir / f"{stem_name}.mid")
+            stem_classifications[stem_name] = cls
+        except Exception as exc:
+            _log(job_dir, f"CLASSIFY_ERROR [{stem_name}]: {exc}")
+            stem_classifications[stem_name] = {}
 
     # Stage 4: Engraving stub
     _set(sid, stage=4, status="engraving", progress=0.95)
 
-    # Build stem list
+    # Build stem list — merge dynamic classification over STEM_META defaults
     stems = []
     for name in DEMUCS_SOURCES:
         if not (stems_dir / f"{name}.wav").exists():
             continue
-        m = STEM_META.get(name, {})
+        m   = STEM_META.get(name, {})
+        cls = stem_classifications.get(name, {})
+        if cls.get("removed"):
+            _log(job_dir, f"STEM_REMOVED [{name}]: silent — skipped")
+            continue
+        stem_name_disp = cls.get("name")       or m.get("name",       name.title())
+        stem_inst      = cls.get("instrument") or m.get("instrument", "Unknown")
+        stem_family    = cls.get("family")     or m.get("family",     "")
+        stem_clef      = cls.get("clef")       or m.get("clef",       "treble")
+
+        # ── Multi-track split: omnizart outputs separate tracks per instrument ─────
+        # Trigger: >1 instrument track with distinct GM programs and ≥10 notes each
+        _split_done = False
+        midi_file = midi_dir / f"{name}.mid"
+        if midi_file.exists() and name == "other":
+            try:
+                import pretty_midi as _pm_mt, re as _re_mt
+                _pm_mt_obj = _pm_mt.PrettyMIDI(str(midi_file))
+                _valid_tracks = [i for i in _pm_mt_obj.instruments if len(i.notes) >= 10]
+                _distinct_progs = len({i.program for i in _valid_tracks if not i.is_drum})
+                if _distinct_progs >= 2 or (len(_valid_tracks) >= 2):
+                    _split_done = True
+                    _log(job_dir, f"MULTI_TRACK_SPLIT [{name}]: {len(_valid_tracks)} tracks")
+                    for _tidx, _tinst in enumerate(_valid_tracks):
+                        _safe_id = _re_mt.sub(r"[^a-z0-9]+", "_",
+                                              (_tinst.name or f"track_{_tidx}").lower()
+                                              ).strip("_")[:18] or f"track_{_tidx}"
+                        _tid = f"{name}_{_safe_id}"
+                        _pm_single = _pm_mt.PrettyMIDI(
+                            initial_tempo=float(analysis.get("tempo", 120)))
+                        _pm_single.instruments.append(_tinst)
+                        _pm_single.write(str(midi_dir / f"{_tid}.mid"))
+                        if _tinst.is_drum:
+                            _tn, _tf, _tc = "Drums", "Percussion", "percussion"
+                        else:
+                            _tn, _tf, _tc = _gm_program_meta(_tinst.program)
+                        _tname = _tinst.name or _tn
+                        stems.append({
+                            "id": _tid, "name": _tname,
+                            "instrument": _tn, "family": _tf, "clef": _tc,
+                            "color": m.get("color", "--s-synth"), "role": "",
+                            "confidence": midi_confs.get(name, 0.0),
+                            "midi": len(_tinst.notes),
+                            "audio_url": f"/work/{sid}/stems/{name}.wav",
+                            "midi_url":  f"/work/{sid}/midi/{_tid}.mid",
+                            "density": 3, "seed": hash(_tid) % 50 + 1, "note": "",
+                        })
+            except Exception as _mte:
+                _log(job_dir, f"MULTI_TRACK_SPLIT_ERROR [{name}]: {_mte}")
+                _split_done = False
+
+        # ── Grand-staff split: if MIDI spans bass+treble registers, emit two staves ──
+        # Trigger: >12% of notes below E3 (MIDI 52) AND >12% above E3
+        if not _split_done and midi_file.exists():
+            try:
+                import pretty_midi as _pm_split
+                _pm_s = _pm_split.PrettyMIDI(str(midi_file))
+                _all_p = [n.pitch for inst in _pm_s.instruments for n in inst.notes]
+                if len(_all_p) >= 20:
+                    _n_bass   = sum(1 for p in _all_p if p < 52)
+                    _n_treble = sum(1 for p in _all_p if p >= 52)
+                    _frac_b   = _n_bass   / len(_all_p)
+                    _frac_t   = _n_treble / len(_all_p)
+                    if _frac_b > 0.12 and _frac_t > 0.12:
+                        # Write split MIDI files
+                        for _sfx, _pred, _clef_s in [
+                            ("_high", lambda p: p >= 52, "treble"),
+                            ("_low",  lambda p: p <  52, "bass"),
+                        ]:
+                            _pm_out = _pm_split.PrettyMIDI(
+                                initial_tempo=float(analysis.get("tempo", 120)))
+                            for _inst in _pm_s.instruments:
+                                _ni = _pm_split.Instrument(
+                                    program=_inst.program,
+                                    is_drum=_inst.is_drum,
+                                    name=_inst.name)
+                                _ni.notes = [n for n in _inst.notes if _pred(n.pitch)]
+                                if _ni.notes:
+                                    _pm_out.instruments.append(_ni)
+                            if _pm_out.instruments:
+                                _pm_out.write(str(midi_dir / f"{name}{_sfx}.mid"))
+                        if (midi_dir / f"{name}_high.mid").exists() and \
+                           (midi_dir / f"{name}_low.mid").exists():
+                            _split_done = True
+                            _lbl_hi = stem_name_disp + " (Treble)"
+                            _lbl_lo = stem_name_disp + " (Bass)"
+                            _log(job_dir, f"GRAND_STAFF_SPLIT [{name}]: "
+                                          f"{_n_bass} bass / {_n_treble} treble notes")
+                            stems.append({
+                                "id": f"{name}_high", "name": _lbl_hi,
+                                "instrument": stem_inst, "family": stem_family,
+                                "clef": "treble", "color": m.get("color", "--s-synth"),
+                                "role": m.get("role", ""), "confidence": midi_confs.get(name, 0.0),
+                                "midi": _n_treble,
+                                "audio_url": f"/work/{sid}/stems/{name}.wav",
+                                "midi_url":  f"/work/{sid}/midi/{name}_high.mid",
+                                "density": 3, "seed": hash(name + "_high") % 50 + 1, "note": "",
+                            })
+                            stems.append({
+                                "id": f"{name}_low", "name": _lbl_lo,
+                                "instrument": stem_inst, "family": stem_family,
+                                "clef": "bass", "color": m.get("color", "--s-synth"),
+                                "role": m.get("role", ""), "confidence": midi_confs.get(name, 0.0),
+                                "midi": _n_bass,
+                                "audio_url": f"/work/{sid}/stems/{name}.wav",
+                                "midi_url":  f"/work/{sid}/midi/{name}_low.mid",
+                                "density": 3, "seed": hash(name + "_low") % 50 + 1, "note": "",
+                            })
+            except Exception as _se:
+                _log(job_dir, f"SPLIT_ERROR [{name}]: {_se}")
+
+        if not _split_done:
+            stems.append({
+                "id":         name,
+                "name":       stem_name_disp,
+                "instrument": stem_inst,
+                "family":     stem_family,
+                "clef":       stem_clef,
+                "color":      m.get("color", "--s-synth"),
+                "role":       m.get("role",  ""),
+                "confidence": midi_confs.get(name, 0.0),
+                "midi":       midi_counts.get(name, 0),
+                "audio_url":  f"/work/{sid}/stems/{name}.wav",
+                "midi_url":   f"/work/{sid}/midi/{name}.mid" if midi_file.exists() else None,
+                "density": 3, "seed": hash(name) % 50 + 1, "note": "",
+            })
+
+    final_meta = {**meta,
+                  "tempo":      analysis["tempo"],
+                  "key":        analysis["key"],
+                  "timeSig":    analysis["timeSig"],
+                  "sampleRate": analysis["sampleRate"],
+                  "bitDepth":   analysis["bitDepth"],
+                  "spectrum":   analysis.get("spectrum", []),
+                  "sepModel":   "HT-Demucs v4 · 6-stem",
+                  "transModel": ("omnizart + basic-pitch" if _OMNIZART_AVAIL and _BASIC_PITCH_AVAIL
+                                 else "omnizart" if _OMNIZART_AVAIL
+                                 else "Spotify basic-pitch" if _BASIC_PITCH_AVAIL
+                                 else "CQT-poly (librosa)"),
+                  "gpu":        _gpu_info()}
+    _log(job_dir,
+         "=== FINAL SUMMARY ===",
+         f"title:       {meta.get('title','?')}",
+         f"artist:      {meta.get('artist','?')}",
+         f"duration:    {meta.get('duration',0):.1f} s",
+         f"tempo:       {analysis['tempo']} BPM",
+         f"key:         {analysis['key']}",
+         f"time_sig:    {analysis['timeSig'][0]}/{analysis['timeSig'][1]}",
+         f"sample_rate: {analysis['sampleRate']} Hz",
+         f"bit_depth:   {analysis['bitDepth']}-bit",
+         f"device:      {_DEVICE}",
+         "midi_counts:",
+         *[f"  {k}: {v} notes" for k, v in sorted(midi_counts.items())],
+         "=== PIPELINE DONE ===")
+
+    # ── Human-readable detection log ──────────────────────────────────────────
+    try:
+        lines = [
+            "═══════════════════════════════════════════════════",
+            "  AEGIS SCORE STUDIO — Detection Report",
+            "═══════════════════════════════════════════════════",
+            f"  Title      : {meta.get('title','?')}",
+            f"  Artist     : {meta.get('artist','?')}",
+            f"  Duration   : {meta.get('duration',0):.1f} s",
+            f"  Source     : {meta.get('source','?')}",
+            "",
+            "── Audio Analysis ─────────────────────────────────",
+            f"  BPM        : {analysis['tempo']}",
+            f"  Key        : {analysis['key']}",
+            f"  Time Sig   : {analysis['timeSig'][0]}/{analysis['timeSig'][1]}",
+            f"  Sample Rate: {analysis['sampleRate']} Hz",
+            f"  Bit Depth  : {analysis['bitDepth']}-bit",
+            "",
+            "── Models Used ────────────────────────────────────",
+            f"  Separation : HT-Demucs v4 · 6-stem",
+            f"  Transcribe : {'omnizart (other) + basic-pitch (melodic)' if _OMNIZART_AVAIL and _BASIC_PITCH_AVAIL else 'omnizart' if _OMNIZART_AVAIL else 'Spotify basic-pitch (ONNX)' if _BASIC_PITCH_AVAIL else 'CQT-poly (librosa)'}",
+            f"  Beat Track : beat_this ISMIR-2024",
+            f"  Device     : {_DEVICE.upper()}",
+            "",
+            "── Detected Stems ─────────────────────────────────",
+        ]
+        for s in stems:
+            cls = stem_classifications.get(s["id"], {})
+            status = "✓ kept" if not s.get("removed") else "✗ removed (silent)"
+            lines += [
+                f"  [{s['id'].upper():6}]  {s['name']:18} {status}",
+                f"           Instrument : {s['instrument']}",
+                f"           Family     : {s['family']}",
+                f"           Clef       : {s['clef']}",
+                f"           MIDI notes : {s['midi']}",
+                f"           Confidence : {s['confidence']:.0f}%",
+            ]
+            if s["id"] == "other":
+                lines.append(f"           Detected as: {s['name']} (spectral classification)")
+            midi_file = job_dir / "midi" / f"{s['id']}.mid"
+            if midi_file.exists() and not s.get("removed"):
+                try:
+                    import pretty_midi as _pm_log
+                    _pm_obj = _pm_log.PrettyMIDI(str(midi_file))
+                    _all_notes = sorted(
+                        [n for inst in _pm_obj.instruments for n in inst.notes],
+                        key=lambda n: n.start,
+                    )
+                    if _all_notes:
+                        lines.append(f"           Detected notes ({len(_all_notes)}):")
+                        _MAX = 200
+                        for _n in _all_notes[:_MAX]:
+                            _name = _pm_log.note_number_to_name(_n.pitch)
+                            _dur  = _n.end - _n.start
+                            lines.append(
+                                f"             {_name:4}  t={_n.start:7.2f}s"
+                                f"  dur={_dur:.2f}s  vel={_n.velocity}"
+                            )
+                        if len(_all_notes) > _MAX:
+                            lines.append(f"             ... +{len(_all_notes) - _MAX} more")
+                except Exception:
+                    pass
+            lines.append("")
+        for stem_name_r in DEMUCS_SOURCES:
+            cls_r = stem_classifications.get(stem_name_r, {})
+            if cls_r.get("removed") and not any(s["id"] == stem_name_r for s in stems):
+                lines.append(f"  [{stem_name_r.upper():6}]  (silent — removed from score)")
+        lines += [
+            "",
+            "═══════════════════════════════════════════════════",
+        ]
+        (job_dir / "detection_log.txt").write_text("\n".join(lines), encoding="utf-8")
+    except Exception as _le:
+        _log(job_dir, f"detection_log write error: {_le}")
+
+    _set(sid, status="done", progress=1.0, stage=4, stems=stems, meta=final_meta)
+
+
+# ── Web MIDI fetch (fast path) ───────────────────────────────────────────────
+_GM_PROGRAM_MAP = [
+    (8,   "Piano",          "Keys",       "treble"),
+    (16,  "Chromatic Perc", "Percussion", "treble"),
+    (24,  "Organ",          "Keys",       "treble"),
+    (32,  "Guitar",         "Strings",    "treble"),
+    (40,  "Bass",           "Bass",       "bass"),
+    (48,  "Strings",        "Strings",    "treble"),
+    (56,  "Ensemble",       "Strings",    "treble"),
+    (64,  "Brass",          "Brass",      "treble"),
+    (72,  "Reed",           "Woodwind",   "treble"),
+    (80,  "Pipe",           "Woodwind",   "treble"),
+    (88,  "Synth Lead",     "Synth",      "treble"),
+    (96,  "Synth Pad",      "Synth",      "treble"),
+    (104, "Synth Effects",  "Synth",      "treble"),
+    (112, "Ethnic",         "World",      "treble"),
+    (120, "Percussive",     "Percussion", "treble"),
+    (128, "Sound Effects",  "Other",      "treble"),
+]
+
+def _gm_program_meta(program: int) -> tuple:
+    for ceil, name, family, clef in _GM_PROGRAM_MAP:
+        if program < ceil:
+            return name, family, clef
+    return "Other", "Other", "treble"
+
+
+def _try_fetch_midi_sync(title: str, artist: str, job_dir: Path):
+    """Search bitmidi.com then freemidi.org for a matching MIDI. Blocking. Returns Path or None."""
+    import urllib.parse, urllib.request, json, re as _re2
+
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        "Accept": "text/html,application/xhtml+xml,*/*",
+    }
+
+    def _get(url, timeout=8):
+        req = urllib.request.Request(url, headers=headers)
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return r.read().decode("utf-8", errors="replace")
+
+    def _save(url, dest: Path, timeout=15):
+        try:
+            req = urllib.request.Request(url, headers=headers)
+            with urllib.request.urlopen(req, timeout=timeout) as r:
+                dest.write_bytes(r.read())
+            return dest.exists() and dest.stat().st_size > 200
+        except Exception:
+            return False
+
+    raw = f"{artist} {title}".strip()
+    # Strip feat/remix/video annotations that confuse search
+    clean = _re2.sub(r"\s*[\(\[【【][^\)\]】]*[\)\]】]", "", raw).strip()[:60]
+
+    # ── bitmidi.com ──────────────────────────────────────────────────────────
+    try:
+        html = _get(f"https://bitmidi.com/search?q={urllib.parse.quote_plus(clean)}")
+        m = _re2.search(r'<script id="__NEXT_DATA__"[^>]*>(.+?)</script>', html, _re2.S)
+        if m:
+            data = json.loads(m.group(1))
+            results = data.get("props", {}).get("pageProps", {}).get("results", [])
+            if results:
+                slug = results[0].get("slug") or str(results[0].get("id", ""))
+                if slug:
+                    page = _get(f"https://bitmidi.com/{slug}")
+                    dm = _re2.search(r'"(https://bitmidi\.com/uploads/[^"]+\.mid)"', page)
+                    if dm:
+                        out = job_dir / "fetched.mid"
+                        if _save(dm.group(1), out):
+                            return out
+                    dm2 = _re2.search(r'href="(/uploads/[^"]+\.mid)"', page)
+                    if dm2:
+                        out = job_dir / "fetched.mid"
+                        if _save("https://bitmidi.com" + dm2.group(1), out):
+                            return out
+    except Exception:
+        pass
+
+    # ── freemidi.org ─────────────────────────────────────────────────────────
+    try:
+        html = _get(f"https://freemidi.org/search?s={urllib.parse.quote_plus(clean)}")
+        lm = _re2.search(r'href="(https?://freemidi\.org/download[^"]+)"', html)
+        if lm:
+            page = _get(lm.group(1))
+            gm = _re2.search(r'href="(https?://freemidi\.org/getter[^"]+)"', page)
+            if not gm:
+                gm = _re2.search(r'"(https?://[^"]+\.mid)"', page)
+            if gm:
+                out = job_dir / "fetched.mid"
+                if _save(gm.group(1), out):
+                    return out
+    except Exception:
+        pass
+
+    return None
+
+
+async def _pipeline_fetched_midi(sid: str, midi_path: Path, audio_path: Path, meta: dict):
+    """Fast-path: use a web-fetched MIDI, skip Demucs + transcription."""
+    import pretty_midi, re as _re3
+    job_dir = midi_path.parent
+    stems_dir = job_dir / "stems"
+    midi_dir  = job_dir / "midi"
+    stems_dir.mkdir(exist_ok=True)
+    midi_dir.mkdir(exist_ok=True)
+    loop = asyncio.get_running_loop()
+
+    _log(job_dir, "=== FAST PATH: WEB MIDI ===", f"file: {midi_path.name}")
+    # Stage 1 slot: audio analysis (replaces Demucs)
+    _set(sid, stage=1, status="separating", progress=0.22)
+    analysis = await loop.run_in_executor(_POOL, _analyze_audio_sync, audio_path, job_dir)
+    # Stage 2 slot: instrument ID (instant — we read it from MIDI program numbers)
+    _set(sid, stage=2, status="identifying", progress=0.62)
+    pm = pretty_midi.PrettyMIDI(str(midi_path))
+    tempo = float(analysis.get("tempo", 120))
+    _set(sid, progress=0.70)
+
+    # Original audio as single "mix" track for WAV playback
+    shutil.copy(audio_path, stems_dir / "mix.wav")
+    stems = [{
+        "id": "mix", "name": "Mix (Audio)", "instrument": "Full Mix",
+        "family": "Audio", "clef": "treble", "color": "--s-synth", "role": "Playback",
+        "confidence": 100.0, "midi": 0,
+        "audio_url": f"/work/{sid}/stems/mix.wav",
+        "midi_url":  None,
+        "density": 0, "seed": 1, "note": "Web-fetched MIDI · stem isolation N/A",
+    }]
+    midi_counts: dict = {}
+    used_ids: dict = {}
+
+    # Stage 3 slot: MIDI import (replaces transcription)
+    _set(sid, stage=3, status="transcribing", progress=0.72)
+    for inst in pm.instruments:
+        if not inst.notes:
+            continue
+        raw_id = _re3.sub(r"[^a-z0-9]+", "_",
+                          (inst.name or "track").lower()).strip("_")[:20] or "track"
+        n = used_ids.get(raw_id, 0)
+        used_ids[raw_id] = n + 1
+        stem_id = raw_id if n == 0 else f"{raw_id}_{n}"
+
+        if inst.is_drum:
+            inst_name, family, clef = "Drums", "Percussion", "percussion"
+        else:
+            inst_name, family, clef = _gm_program_meta(inst.program)
+
+        pm_out = pretty_midi.PrettyMIDI(initial_tempo=tempo)
+        inst_copy = pretty_midi.Instrument(
+            program=inst.program, is_drum=inst.is_drum,
+            name=inst.name or inst_name)
+        inst_copy.notes = list(inst.notes)
+        pm_out.instruments.append(inst_copy)
+        pm_out.write(str(midi_dir / f"{stem_id}.mid"))
+
         stems.append({
-            "id": name, "name": m.get("name", name.title()),
-            "instrument": m.get("instrument", "Unknown"),
-            "family": m.get("family", ""), "clef": m.get("clef", "treble"),
-            "color": m.get("color", "--s-synth"), "role": m.get("role", ""),
-            "confidence": 90.0, "midi": midi_counts.get(name, 0),
-            "audio_url": f"/work/{sid}/stems/{name}.wav",
-            "midi_url": f"/work/{sid}/midi/{name}.mid" if (midi_dir / f"{name}.mid").exists() else None,
-            "density": 3, "seed": hash(name) % 50 + 1, "note": "",
+            "id":         stem_id,
+            "name":       inst.name or inst_name,
+            "instrument": inst_name,
+            "family":     family,
+            "clef":       clef,
+            "color":      "--s-synth",
+            "role":       "",
+            "confidence": 100.0,
+            "midi":       len(inst.notes),
+            "audio_url":  None,
+            "midi_url":   f"/work/{sid}/midi/{stem_id}.mid",
+            "density": 3, "seed": hash(stem_id) % 50 + 1, "note": "",
         })
+        midi_counts[stem_id] = len(inst.notes)
 
-    _set(sid, status="done", progress=1.0, stage=4, stems=stems,
-         meta={**meta, "tempo": 120, "key": "A minor", "timeSig": [4, 4],
-               "sampleRate": 44100, "bitDepth": 24,
-               "sepModel": "HT-Demucs v4 · 6-stem",
-               "transModel": "librosa-pyin",
-               "gpu": _gpu_info()})
+    if len(stems) <= 1:
+        raise ValueError("Fetched MIDI has no playable tracks")
+
+    _set(sid, stage=4, status="engraving", progress=0.92)
+
+    final_meta = {**meta,
+                  "tempo":      analysis["tempo"],
+                  "key":        analysis["key"],
+                  "timeSig":    analysis["timeSig"],
+                  "sampleRate": analysis["sampleRate"],
+                  "bitDepth":   analysis["bitDepth"],
+                  "spectrum":   analysis.get("spectrum", []),
+                  "sepModel":   "Web fetch · no stem separation",
+                  "transModel": "bitmidi.com / freemidi.org",
+                  "gpu":        _gpu_info()}
+
+    _log(job_dir,
+         "=== FAST PATH DONE ===",
+         f"tracks:  {len(stems)-1}",
+         f"tempo:   {analysis['tempo']} BPM",
+         f"key:     {analysis['key']}",
+         *[f"  {k}: {v} notes" for k, v in sorted(midi_counts.items())])
+
+    try:
+        dlines = [
+            "═══════════════════════════════════════════════════",
+            "  AEGIS SCORE STUDIO — Detection Report (Web MIDI)",
+            "═══════════════════════════════════════════════════",
+            f"  Title      : {meta.get('title','?')}",
+            f"  Artist     : {meta.get('artist','?')}",
+            f"  Duration   : {meta.get('duration',0):.1f} s",
+            f"  Source     : {meta.get('source','?')}",
+            "",
+            "── Audio Analysis ─────────────────────────────────",
+            f"  BPM        : {analysis['tempo']}",
+            f"  Key        : {analysis['key']}",
+            f"  Time Sig   : {analysis['timeSig'][0]}/{analysis['timeSig'][1]}",
+            f"  Sample Rate: {analysis['sampleRate']} Hz",
+            f"  Bit Depth  : {analysis['bitDepth']}-bit",
+            "",
+            "── Pipeline ───────────────────────────────────────",
+            "  MIDI source: Fetched from web (bitmidi.com / freemidi.org)",
+            "  Separation : Skipped — stem isolation unavailable",
+            "  Transcribe : Skipped — using web MIDI",
+            "",
+            "── MIDI Tracks ────────────────────────────────────",
+        ]
+        for s in stems[1:]:
+            dlines += [
+                f"  [{s['id'][:6].upper():6}]  {s['name']:20}  {s['midi']} notes",
+                f"           Instrument : {s['instrument']}",
+                f"           Family     : {s['family']}",
+                "",
+            ]
+        dlines.append("═══════════════════════════════════════════════════")
+        (job_dir / "detection_log.txt").write_text("\n".join(dlines), encoding="utf-8")
+    except Exception as _le:
+        _log(job_dir, f"detection_log write error: {_le}")
+
+    _set(sid, status="done", progress=1.0, stage=4, stems=stems, meta=final_meta)
 
 
 # ── Background pipeline: URL ──────────────────────────────────────────────────
@@ -202,6 +1111,7 @@ async def pipeline_url(sid: str, url: str):
     audio_path = job_dir / "audio.wav"
 
     try:
+        _log(job_dir, "=== PIPELINE START (URL) ===", f"sid: {sid}", f"url: {url}")
         _set(sid, stage=0, status="downloading", progress=0.0)
         import yt_dlp
         ydl_opts = {
@@ -211,9 +1121,14 @@ async def pipeline_url(sid: str, url: str):
             "outtmpl": str(job_dir / "audio"),
             "quiet": True,
             "no_warnings": True,
-            "extractor_args": {"youtube": {"player_client": ["android", "web"]}},
+            # ios+mweb = current yt-dlp defaults; android+web as fallbacks
+            "extractor_args": {"youtube": {"player_client": ["ios", "mweb", "android", "web"]}},
+            "noplaylist": True,
+            "extractor_retries": 5,
+            "fragment_retries": 10,
+            "retries": 5,
         }
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         def _download():
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 return ydl.extract_info(url, download=True)
@@ -232,18 +1147,46 @@ def _download():
             resolved.rename(audio_path)
         elif not resolved:
             raise FileNotFoundError(f"yt-dlp produced no WAV in {job_dir}. Is ffmpeg on PATH?")
+        _log(job_dir,
+             f"download_ok: {meta['title']}",
+             f"uploader:    {meta['artist']}",
+             f"duration:    {meta['duration']} s")
         _set(sid, meta=meta, progress=0.18)
 
+        # ── Fast path: try fetching existing MIDI (silent, part of normal flow) ──
+        fetched = await loop.run_in_executor(
+            None, _try_fetch_midi_sync, meta["title"], meta.get("artist", ""), job_dir)
+        if fetched:
+            _log(job_dir, f"midi_fetch_ok: {fetched.name} ({fetched.stat().st_size} bytes)")
+            await _pipeline_fetched_midi(sid, fetched, audio_path, meta)
+            URL_CACHE[url] = sid
+            return
+
+        _log(job_dir, "midi_fetch: none found — running full pipeline")
         await _separate_and_transcribe(sid, audio_path, meta)
         URL_CACHE[url] = sid
 
     except Exception as exc:
-        _set(sid, status="error", error=str(exc), progress=1.0)
+        err_str = str(exc)
+        _log(job_dir, f"PIPELINE ERROR: {exc}", traceback.format_exc())
+        # Friendlier messages for common failures
+        _lower = err_str.lower()
+        if "sign in" in _lower or "age" in _lower or "confirm your age" in _lower:
+            err_str = "Age-restricted video — YouTube requires sign-in. Try a different video."
+        elif "private" in _lower:
+            err_str = "Private video — not accessible."
+        elif "unavailable" in _lower or "removed" in _lower:
+            err_str = "Video unavailable or removed by uploader."
+        elif "ffmpeg" in _lower:
+            err_str = "ffmpeg not found on PATH — required for audio conversion."
+        _set(sid, status="error", error=err_str)
 
 
 # ── Background pipeline: local file ──────────────────────────────────────────
 async def pipeline_file(sid: str, audio_path: Path, filename: str):
+    job_dir = audio_path.parent
     try:
+        _log(job_dir, "=== PIPELINE START (FILE) ===", f"sid: {sid}", f"file: {filename}")
         _set(sid, stage=0, status="converting", progress=0.05)
         # If not WAV, convert with ffmpeg
         if audio_path.suffix.lower() != ".wav":
@@ -262,20 +1205,23 @@ async def pipeline_file(sid: str, audio_path: Path, filename: str):
             "thumb":    "",
             "source":   filename,
         }
+        _log(job_dir, f"file_ok: {filename}  duration={int(info.duration)}s")
         _set(sid, meta=meta, progress=0.18)
         await _separate_and_transcribe(sid, audio_path, meta)
 
     except Exception as exc:
-        _set(sid, status="error", error=str(exc), progress=1.0)
+        _log(job_dir, f"PIPELINE ERROR: {exc}", traceback.format_exc())
+        _set(sid, status="error", error=str(exc))
 
 
 # ── Routes ────────────────────────────────────────────────────────────────────
 @app.post("/api/analyze")
 async def analyze(req: AnalyzeRequest, bg: BackgroundTasks):
     url = req.url.strip()
-    cached = URL_CACHE.get(url)
-    if cached and JOBS.get(cached, {}).get("status") == "done":
-        return {"session_id": cached, "cached": True}
+    if not req.force:
+        cached = URL_CACHE.get(url)
+        if cached and JOBS.get(cached, {}).get("status") == "done":
+            return {"session_id": cached, "cached": True}
     sid = str(uuid.uuid4())
     JOBS[sid] = {"status": "queued", "progress": 0.0, "stage": -1,
                  "meta": {}, "stems": [], "error": None}
@@ -300,34 +1246,75 @@ async def upload(bg: BackgroundTasks, file: UploadFile = File(...)):
     return {"session_id": sid}
 
 
+@app.post("/api/resume/{sid}")
+async def resume(sid: str, bg: BackgroundTasks):
+    """Resume processing of a session whose audio.wav is already on disk."""
+    job_dir = WORK_DIR / sid
+    audio_path = job_dir / "audio.wav"
+    if not audio_path.exists():
+        raise HTTPException(404, "no audio found for this session")
+    if JOBS.get(sid, {}).get("status") in ("separating", "transcribing", "done"):
+        return {"session_id": sid, "status": JOBS[sid]["status"]}
+    import soundfile as sf
+    info = sf.info(str(audio_path))
+    meta = {"title": sid[:8], "artist": "Local file", "duration": int(info.duration),
+            "thumb": "", "source": "resumed"}
+    JOBS[sid] = {"status": "queued", "progress": 0.18, "stage": 0,
+                 "meta": meta, "stems": [], "error": None}
+    bg.add_task(_separate_and_transcribe, sid, audio_path, meta)
+    return {"session_id": sid}
+
+
 @app.get("/api/status/{sid}")
 async def status(sid: str):
     job = JOBS.get(sid)
     if not job:
-        raise HTTPException(404, "session not found")
+        # Server restarted — try reading persisted session from disk
+        session_file = WORK_DIR / sid / "session.json"
+        if session_file.exists():
+            try:
+                import json as _json
+                job = _json.loads(session_file.read_text(encoding="utf-8"))
+                JOBS[sid] = job  # reload into memory
+            except Exception:
+                raise HTTPException(404, "session not found")
+        else:
+            raise HTTPException(404, "session not found")
     return JSONResponse(job)
 
 
+@app.get("/api/detection_log/{sid}")
+async def get_detection_log(sid: str):
+    log_path = WORK_DIR / sid / "detection_log.txt"
+    if not log_path.exists():
+        raise HTTPException(404, "log not found")
+    from fastapi.responses import PlainTextResponse
+    return PlainTextResponse(log_path.read_text(encoding="utf-8"))
+
+
 @app.get("/api/midi/{sid}/{stem_name}")
 async def get_midi_notes(sid: str, stem_name: str):
     midi_path = WORK_DIR / sid / "midi" / f"{stem_name}.mid"
     if not midi_path.exists():
         raise HTTPException(404, "MIDI not found")
-    import pretty_midi
-    pm = pretty_midi.PrettyMIDI(str(midi_path))
-    notes = []
-    for inst in pm.instruments:
-        for note in inst.notes:
-            notes.append({
-                "pitch": note.pitch,
-                "start": round(float(note.start), 4),
-                "end": round(float(note.end), 4),
-                "velocity": note.velocity,
-                "drum": bool(inst.is_drum),
-            })
-    notes.sort(key=lambda n: n["start"])
-    return {"notes": notes, "end_time": round(float(pm.get_end_time()), 2)}
+    try:
+        import pretty_midi
+        pm = pretty_midi.PrettyMIDI(str(midi_path))
+        notes = []
+        for inst in pm.instruments:
+            for note in inst.notes:
+                notes.append({
+                    "pitch": note.pitch,
+                    "start": round(float(note.start), 4),
+                    "end": round(float(note.end), 4),
+                    "velocity": note.velocity,
+                    "drum": bool(inst.is_drum),
+                })
+        notes.sort(key=lambda n: n["start"])
+        return {"notes": notes, "end_time": round(float(pm.get_end_time()), 2)}
+    except Exception as exc:
+        raise HTTPException(422, f"MIDI parse error: {exc}")
 
 
 app.mount("/work", StaticFiles(directory=str(WORK_DIR)), name="work")
-app.mount("/", StaticFiles(directory=".", html=True), name="static")
+app.mount("/", StaticFiles(directory=os.environ.get("AEGIS_STATIC_DIR", "."), html=True), name="static")
diff --git a/server_launch.py b/server_launch.py
new file mode 100644
index 0000000..07f5994
--- /dev/null
+++ b/server_launch.py
@@ -0,0 +1,21 @@
+"""
+Entry point for the PyInstaller-compiled server binary.
+Sets AEGIS_WORK_DIR / AEGIS_STATIC_DIR before importing server so paths resolve correctly.
+"""
+import sys
+import os
+from pathlib import Path
+
+if getattr(sys, "frozen", False):
+    # Running inside a PyInstaller bundle
+    _static_dir = Path(sys._MEIPASS)                      # extracted data lives here
+    _work_dir   = Path(sys.executable).parent / "work"    # writable, next to .exe
+    os.environ.setdefault("AEGIS_STATIC_DIR", str(_static_dir))
+    os.environ.setdefault("AEGIS_WORK_DIR",   str(_work_dir))
+    _work_dir.mkdir(exist_ok=True, parents=True)
+
+import uvicorn
+from server import app  # noqa: E402 — must come after env vars are set
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=7471, log_level="warning")
diff --git a/server_launch.spec b/server_launch.spec
new file mode 100644
index 0000000..62bd376
--- /dev/null
+++ b/server_launch.spec
@@ -0,0 +1,79 @@
+# -*- mode: python ; coding: utf-8 -*-
+from PyInstaller.utils.hooks import collect_all
+from pathlib import Path
+
+ROOT = Path(SPECPATH)
+
+datas = [
+    (str(ROOT / 'index.html'), '.'),
+    (str(ROOT / 'css'),        'css'),
+    (str(ROOT / 'js'),         'js'),
+]
+binaries = []
+hiddenimports = [
+    'uvicorn.logging',
+    'uvicorn.loops', 'uvicorn.loops.auto',
+    'uvicorn.protocols', 'uvicorn.protocols.http',
+    'uvicorn.protocols.http.auto',
+    'uvicorn.protocols.http.httptools_impl',
+    'uvicorn.protocols.http.h11_impl',
+    'uvicorn.protocols.websockets',
+    'uvicorn.protocols.websockets.auto',
+    'uvicorn.protocols.websockets.wsproto_impl',
+    'uvicorn.lifespan', 'uvicorn.lifespan.on', 'uvicorn.lifespan.off',
+    'starlette', 'starlette.staticfiles', 'starlette.routing',
+    'starlette.middleware', 'starlette.responses',
+    'librosa', 'librosa.core', 'librosa.feature',
+    'librosa.beat', 'librosa.onset',
+    'pretty_midi', 'soundfile', 'yt_dlp',
+    'demucs', 'demucs.pretrained', 'demucs.apply', 'demucs.audio',
+    'torch', 'sklearn', 'scipy', 'scipy.signal', 'scipy.ndimage',
+]
+
+for pkg in ('librosa', 'demucs', 'yt_dlp'):
+    d, b, h = collect_all(pkg)
+    datas += d; binaries += b; hiddenimports += h
+
+a = Analysis(
+    [str(ROOT / 'server_launch.py')],
+    pathex=[str(ROOT)],
+    binaries=binaries,
+    datas=datas,
+    hiddenimports=hiddenimports,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    [],
+    exclude_binaries=True,
+    name='server_launch',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)
+
+# Name must be 'server_dist' — electron-builder copies dist/server_dist/ into resources
+coll = COLLECT(
+    exe,
+    a.binaries,
+    a.datas,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    name='server_dist',
+)
diff --git a/setup.bat b/setup.bat
new file mode 100644
index 0000000..6ee1d0a
--- /dev/null
+++ b/setup.bat
@@ -0,0 +1,205 @@
+@echo off
+setlocal enabledelayedexpansion
+cd /d "%~dp0"
+
+echo.
+echo ============================================================
+echo   Aegis Score Studio -- First-Time Setup
+echo ============================================================
+echo.
+
+:: ── 0. Prerequisites check ───────────────────────────────────────────────────
+where node >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Node.js not found.
+    echo        Download from https://nodejs.org ^(LTS^)
+    pause & exit /b 1
+)
+where python >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python not found on PATH.
+    echo        Download Python 3.11+ from https://python.org
+    pause & exit /b 1
+)
+
+for /f "tokens=2" %%v in ('python --version 2^>^&1') do set PYVER=%%v
+echo System Python: %PYVER%
+
+where ffmpeg >nul 2>&1
+if errorlevel 1 (
+    echo WARNING: ffmpeg not found -- audio conversion will fail.
+    echo          Download from https://ffmpeg.org and add to PATH.
+    echo          Continuing anyway...
+    echo.
+)
+
+:: ── 1. npm dependencies ──────────────────────────────────────────────────────
+echo [1/5] Installing Node.js dependencies...
+call npm install
+if errorlevel 1 (
+    echo ERROR: npm install failed.
+    pause & exit /b 1
+)
+echo       Done.
+echo.
+
+:: ── 2. Main Python dependencies (system Python, 3.10+) ──────────────────────
+echo [2/5] Installing main Python dependencies...
+echo       ^(fastapi, demucs, librosa, basic-pitch, yt-dlp, etc.^)
+python -m pip install --upgrade pip -q
+python -m pip install ^
+    fastapi ^
+    "uvicorn[standard]" ^
+    yt-dlp ^
+    "demucs>=4.0.1" ^
+    torch ^
+    torchaudio ^
+    "librosa>=0.10.0" ^
+    "pretty-midi>=0.2.10" ^
+    "soundfile>=0.12.1" ^
+    python-multipart ^
+    basic-pitch ^
+    beat-this
+if errorlevel 1 (
+    echo WARNING: Some packages may have failed. Check output above.
+    echo          The app may still work without optional packages.
+)
+echo       Done.
+echo.
+
+:: ── 3. omnizart isolated environment ────────────────────────────────────────
+echo [3/5] Setting up omnizart ^(orchestral AI^)
+echo.
+echo       Requires: Python 3.9 64-bit ^(TensorFlow needs 64-bit^)
+echo       omnizart's dependency madmom can't compile on Windows,
+echo       so we install omnizart --no-deps and supply its real deps manually.
+echo.
+
+set OMNI_PY=
+set OMNI_ENV=C:\omnizart_env
+
+:: Check 64-bit Python 3.9 via common install paths (prefer explicit paths over py launcher
+:: because py launcher may return 32-bit installs which TensorFlow rejects)
+for %%p in (
+    "C:\Python39\python.exe"
+    "%LOCALAPPDATA%\Programs\Python\Python39\python.exe"
+    "C:\Program Files\Python39\python.exe"
+) do (
+    if "!OMNI_PY!"=="" (
+        if exist %%p (
+            :: Verify it's 64-bit
+            %%p -c "import struct; exit(0 if struct.calcsize('P')*8==64 else 1)" >nul 2>&1
+            if not errorlevel 1 set OMNI_PY=%%p
+        )
+    )
+)
+
+:: Try py launcher as fallback (may or may not be 64-bit)
+if "!OMNI_PY!"=="" (
+    py -3.9 --version >nul 2>&1
+    if not errorlevel 1 (
+        py -3.9 -c "import struct; exit(0 if struct.calcsize('P')*8==64 else 1)" >nul 2>&1
+        if not errorlevel 1 set OMNI_PY=py -3.9
+    )
+)
+
+if "!OMNI_PY!"=="" (
+    echo       64-bit Python 3.9 NOT FOUND.
+    echo.
+    echo       omnizart DISABLED. To enable orchestral AI transcription:
+    echo         1. Download Python 3.9.13 64-bit installer:
+    echo            https://www.python.org/downloads/release/python-3913/
+    echo            ^(scroll to Files ^> Windows installer ^(64-bit^)^)
+    echo         2. Install to C:\Python39  ^(don't replace system Python^)
+    echo         3. Re-run setup.bat
+    echo.
+    echo       App still works -- uses basic-pitch for all stems instead.
+    goto :skip_omnizart
+)
+
+echo       Found 64-bit Python 3.9: !OMNI_PY!
+echo.
+
+if exist "!OMNI_ENV!\Scripts\python.exe" (
+    echo       omnizart env already exists. Delete !OMNI_ENV! to reinstall.
+    goto :download_models
+)
+
+echo       Creating virtual environment at !OMNI_ENV! ...
+!OMNI_PY! -m venv !OMNI_ENV!
+if errorlevel 1 ( echo ERROR: venv creation failed. & goto :skip_omnizart )
+
+echo       Upgrading pip...
+"!OMNI_ENV!\Scripts\python.exe" -m pip install --upgrade pip -q
+
+echo       Installing omnizart dependencies ^(skipping madmom -- Windows incompatible^)...
+echo       This downloads TensorFlow ~500 MB, may take 10+ min...
+"!OMNI_ENV!\Scripts\pip.exe" install ^
+    "numpy<2.0" ^
+    "tensorflow>=2.3,<2.14" ^
+    librosa ^
+    scipy ^
+    mir_eval ^
+    pretty_midi ^
+    h5py ^
+    click ^
+    colorama ^
+    pyyaml
+if errorlevel 1 (
+    echo ERROR: Dependency install failed. Check output above.
+    rmdir /s /q "!OMNI_ENV!"
+    goto :skip_omnizart
+)
+
+echo       Installing omnizart ^(no-deps -- madmom excluded^)...
+"!OMNI_ENV!\Scripts\pip.exe" install omnizart --no-deps
+if errorlevel 1 (
+    echo ERROR: omnizart install failed.
+    rmdir /s /q "!OMNI_ENV!"
+    goto :skip_omnizart
+)
+
+echo       Installing remaining omnizart deps ^(jsonschema, sherpa-onnx, tf-keras, etc.^)...
+"!OMNI_ENV!\Scripts\pip.exe" install jsonschema tqdm Pillow matplotlib sherpa-onnx tf-keras
+if errorlevel 1 (
+    echo WARNING: Some optional deps failed. omnizart may still work.
+)
+
+:download_models
+echo.
+echo [4/5] Pre-loading omnizart music model ^(auto-downloads ~300 MB on first use^)...
+"!OMNI_ENV!\Scripts\python.exe" -c "from omnizart.music import app; print('omnizart ready')" 2>nul
+if errorlevel 1 (
+    echo WARNING: omnizart import check failed. Will retry on first transcription.
+)
+
+echo       omnizart ready.
+goto :done_omnizart
+
+:skip_omnizart
+echo       Skipping omnizart setup.
+
+:done_omnizart
+echo.
+
+:: ── 4. Write .env so launch script knows paths ───────────────────────────────
+echo [5/5] Writing launch configuration...
+
+if exist "C:\omnizart_env\Scripts\python.exe" (
+    echo OMNIZART_PYTHON=C:\omnizart_env\Scripts\python.exe> .env.local
+    echo       omnizart path saved to .env.local
+) else (
+    if exist .env.local del .env.local
+    echo       No omnizart env -- .env.local not written.
+)
+
+:: Mark setup complete
+echo %date% %time%> .setup_complete
+
+echo.
+echo ============================================================
+echo   Setup complete!
+echo   Run "Launch Aegis.bat" to start the app.
+echo ============================================================
+echo.
+pause
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/integration/.gitkeep b/tests/integration/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/integration/test_api.py b/tests/integration/test_api.py
new file mode 100644
index 0000000..c4b9df3
--- /dev/null
+++ b/tests/integration/test_api.py
@@ -0,0 +1,51 @@
+"""Integration tests for FastAPI routes — no real audio processing."""
+import pytest
+from fastapi.testclient import TestClient
+from unittest.mock import patch, AsyncMock
+from backend.api.app import create_app
+
+
+@pytest.fixture(scope="module")
+def client():
+    app = create_app()
+    return TestClient(app)
+
+
+def test_analyze_returns_session_id(client):
+    with patch("backend.services.pipeline.pipeline_url", new_callable=AsyncMock):
+        resp = client.post("/api/analyze", json={"url": "https://youtu.be/test"})
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "session_id" in data
+    assert len(data["session_id"]) == 36  # UUID
+
+
+def test_status_404_unknown_session(client):
+    resp = client.get("/api/status/00000000-0000-0000-0000-000000000000")
+    assert resp.status_code == 404
+
+
+def test_status_returns_job_after_analyze(client):
+    with patch("backend.services.pipeline.pipeline_url", new_callable=AsyncMock):
+        resp = client.post("/api/analyze", json={"url": "https://youtu.be/xyz"})
+    sid = resp.json()["session_id"]
+    status = client.get(f"/api/status/{sid}")
+    assert status.status_code == 200
+    data = status.json()
+    assert data["status"] in ("queued", "downloading", "done", "error")
+
+
+def test_midi_404_nonexistent(client):
+    resp = client.get("/api/midi/fakesid/drums")
+    assert resp.status_code == 404
+
+
+def test_history_returns_list(client):
+    resp = client.get("/api/history")
+    assert resp.status_code == 200
+    assert isinstance(resp.json(), list)
+
+
+def test_upload_no_file(client):
+    resp = client.post("/api/upload")
+    assert resp.status_code == 422   # unprocessable — no file field
diff --git a/tests/unit/.gitkeep b/tests/unit/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/unit/test_pipeline_helpers.py b/tests/unit/test_pipeline_helpers.py
new file mode 100644
index 0000000..5ff5649
--- /dev/null
+++ b/tests/unit/test_pipeline_helpers.py
@@ -0,0 +1,46 @@
+"""Unit tests for pipeline utility functions — no audio I/O needed."""
+import pytest
+from pathlib import Path
+from backend.db.database import init_db
+from backend.db.models import Session as DbSession, Stem as DbStem
+from backend.services.pipeline import STEM_META, DEMUCS_SOURCES, _gpu_info
+
+
+def test_stem_meta_all_sources():
+    """Every demucs source must have metadata."""
+    for src in DEMUCS_SOURCES:
+        assert src in STEM_META, f"Missing STEM_META entry for: {src}"
+
+
+def test_stem_meta_required_keys():
+    required = {"name", "instrument", "family", "clef", "color", "role"}
+    for src, meta in STEM_META.items():
+        missing = required - meta.keys()
+        assert not missing, f"{src} missing keys: {missing}"
+
+
+def test_gpu_info_returns_dict():
+    info = _gpu_info()
+    assert isinstance(info, dict)
+    assert "model" in info
+    assert "vram" in info
+    assert "vramTotal" in info
+    assert info["vram"] >= 0
+    assert info["vramTotal"] >= 0
+
+
+def test_db_init(tmp_path, monkeypatch):
+    """DB init creates tables without error."""
+    import backend.db.database as db_mod
+    monkeypatch.setattr(db_mod, "DB_PATH", tmp_path / "test.db")
+    monkeypatch.setattr(db_mod, "_ENGINE",
+        __import__("sqlalchemy").create_engine(f"sqlite:///{tmp_path}/test.db",
+            connect_args={"check_same_thread": False}))
+    from backend.db.models import Base
+    Base.metadata.create_all(bind=db_mod._ENGINE)
+    # Should not raise
+
+
+def test_demucs_sources_order():
+    """Separation order matches expected 6-stem model."""
+    assert DEMUCS_SOURCES == ["drums", "bass", "other", "vocals", "guitar", "piano"]
diff --git a/tests/unit/test_schemas.py b/tests/unit/test_schemas.py
new file mode 100644
index 0000000..a82bca0
--- /dev/null
+++ b/tests/unit/test_schemas.py
@@ -0,0 +1,41 @@
+"""Pydantic schema validation tests."""
+import pytest
+from pydantic import ValidationError
+from backend.models.schemas import (
+    JobState, JobStatus, GpuInfo, StemSchema, AnalyzeRequest, MidiNote, MidiResponse
+)
+
+
+def test_job_state_defaults():
+    j = JobState()
+    assert j.status == JobStatus.QUEUED
+    assert j.progress == 0.0
+    assert j.stage == -1
+    assert j.stems == []
+    assert j.error is None
+
+
+def test_analyze_request_strips_whitespace():
+    req = AnalyzeRequest(url="  https://youtu.be/abc  ")
+    # url stored as-is; stripping done in router
+    assert "https" in req.url
+
+
+def test_gpu_info_defaults():
+    g = GpuInfo()
+    assert g.model == "CPU"
+    assert g.vram == 0.0
+    assert g.vram_total == 0.0
+
+
+def test_midi_note_validation():
+    n = MidiNote(pitch=60, start=0.0, end=1.0, velocity=80, drum=False)
+    assert n.pitch == 60
+
+    with pytest.raises(ValidationError):
+        MidiNote(pitch="bad", start=0.0, end=1.0, velocity=80, drum=False)
+
+
+def test_midi_response():
+    r = MidiResponse(notes=[], end_time=0.0)
+    assert r.notes == []