Upload folder using huggingface_hub

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(docker run:*)"
+    ]
+  }
+}

.dockerignore

@@ -0,0 +1,6 @@
+frontend/node_modules
+frontend/dist
+**/__pycache__
+*.pyc
+.git
+plan.md

.gitattributes

@@ -33,3 +33,15 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/Bass.mp3 filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/Drums.mp3 filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/Guitar.mp3 filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/original.mp3 filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/Other.mp3 filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/Piano.mp3 filter=lfs diff=lfs merge=lfs -text
+backend/examples/default/Vocals.mp3 filter=lfs diff=lfs merge=lfs -text
+frontend/node_modules/@esbuild/win32-x64/esbuild.exe filter=lfs diff=lfs merge=lfs -text
+frontend/node_modules/@rollup/rollup-win32-x64-gnu/rollup.win32-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
+frontend/node_modules/@rollup/rollup-win32-x64-msvc/rollup.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text
+frontend/node_modules/@tailwindcss/oxide-win32-x64-msvc/tailwindcss-oxide.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text
+frontend/node_modules/lightningcss-win32-x64-msvc/lightningcss.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,29 @@
+# Stage 1: Build frontend
+FROM node:20-slim AS frontend-build
+WORKDIR /app/frontend
+COPY frontend/package.json frontend/package-lock.json ./
+RUN npm ci
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: Runtime
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg gcc libc6-dev && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY backend/requirements.txt backend/requirements.txt
+RUN pip install --no-cache-dir -r backend/requirements.txt
+
+COPY --from=frontend-build /app/frontend/dist frontend/dist
+COPY backend/ backend/
+
+EXPOSE 7860
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+
+CMD ["python", "-m", "uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,10 @@
 ---
 title: Stem Separator
-emoji: 👁
+emoji: "\U0001F3B5"
 colorFrom: purple
-colorTo: yellow
+colorTo: pink
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

WORKFLOWS.md

@@ -0,0 +1,11 @@
+# stem-separator development workflows
+
+# to run locally
+
+```bash
+docker build -t stem-separator .
+docker run -p 7860:7860 stem-separator                      // for cpu only (slower)
+       OR
+docker run --gpus all -p 7860:7860 stem-separator           // for gpu enabled (much faster)
+```
+Then open http://localhost:7860

backend/examples/default/Bass.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ade21887af48358d366ae8d7949d221a1ce010e92146fa0079c7d682ad8ba32
+size 567422

backend/examples/default/Drums.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c79ed43997db1b848b1103fe361fa48dfc5598f48bfc20437ef2051f192d7ac
+size 567422

backend/examples/default/Guitar.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fa01630da476372fb4f72550e61a6ff5bad594f337941f7e700d924b56494ce
+size 567422

backend/examples/default/Other.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f303284a10ffcd3c88b9e502234404de5b9befd60639de55b1574b5bf3407bb
+size 567422

backend/examples/default/Piano.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24401442c2da04b20cf794e39b480f8275cfc367d3659f1a45e1b2a49901af88
+size 567422

backend/examples/default/README.md

@@ -0,0 +1,11 @@
+Place the bundled example audio files for the demo flow in this directory.
+
+Expected filenames:
+
+- `original.mp3`
+- `Vocals.mp3`
+- `Drums.mp3`
+- `Bass.mp3`
+- `Guitar.mp3`
+- `Piano.mp3`
+- `Other.mp3`

backend/examples/default/Vocals.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba2bd33b2e66055c21f75d1058627de88783456c9c7d54a62a598888407637da
+size 567422

backend/examples/default/original.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efb3d5f483fa75556f22abd1470fbffd425106c8907707166e79c4a45a16ea19
+size 378252

backend/file_manager.py

@@ -0,0 +1,124 @@
+import os
+import shutil
+import time
+import uuid
+import asyncio
+import json
+from pathlib import Path
+
+BASE_DIR = Path("/tmp/stem-sep")
+MAX_AGE_SECONDS = 30 * 60  # 30 minutes
+CLEANUP_INTERVAL = 5 * 60  # 5 minutes
+
+
+def create_job() -> str:
+    job_id = uuid.uuid4().hex[:12]
+    job_dir = BASE_DIR / job_id
+    job_dir.mkdir(parents=True, exist_ok=True)
+    # Touch a marker so we can track creation time
+    (job_dir / ".created").write_text(str(time.time()))
+    return job_id
+
+
+def get_job_dir(job_id: str) -> Path:
+    return BASE_DIR / job_id
+
+
+def save_upload(job_id: str, filename: str, content: bytes) -> Path:
+    job_dir = get_job_dir(job_id)
+    ext = Path(filename).suffix or ".wav"
+    input_path = job_dir / f"input{ext}"
+    input_path.write_bytes(content)
+    return input_path
+
+
+def save_imported_audio(job_id: str, source_filename: str, content: bytes) -> Path:
+    return save_upload(job_id, source_filename, content)
+
+
+def get_input_file(job_id: str) -> Path | None:
+    job_dir = get_job_dir(job_id)
+    if not job_dir.exists():
+        return None
+
+    for file in job_dir.iterdir():
+        if file.is_file() and file.name.startswith("input"):
+            return file
+    return None
+
+
+def get_metadata_path(job_id: str) -> Path:
+    return get_job_dir(job_id) / "metadata.json"
+
+
+def save_job_metadata(job_id: str, metadata: dict) -> Path:
+    path = get_metadata_path(job_id)
+    path.write_text(json.dumps(metadata, indent=2), encoding="utf-8")
+    return path
+
+
+def load_job_metadata(job_id: str) -> dict | None:
+    path = get_metadata_path(job_id)
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def get_output_dir(job_id: str) -> Path:
+    out = get_job_dir(job_id) / "stems"
+    out.mkdir(parents=True, exist_ok=True)
+    return out
+
+
+def list_stem_files(job_id: str) -> dict[str, str]:
+    """Find all stem audio files, checking stems subdir and job root."""
+    result = {}
+    audio_exts = {".wav", ".mp3", ".flac", ".aac"}
+    for check_dir in [get_output_dir(job_id), get_job_dir(job_id)]:
+        if not check_dir.exists():
+            continue
+        for f in check_dir.iterdir():
+            if f.is_file() and f.suffix.lower() in audio_exts and not f.name.startswith("input") and f.stem not in result:
+                result[f.stem] = f.name
+    return result
+
+
+def get_file_path(job_id: str, filename: str) -> Path | None:
+    # Check stems dir first, then job root
+    stem_path = get_output_dir(job_id) / filename
+    if stem_path.exists():
+        return stem_path
+    root_path = get_job_dir(job_id) / filename
+    if root_path.exists():
+        return root_path
+    return None
+
+
+def delete_job(job_id: str):
+    job_dir = get_job_dir(job_id)
+    if job_dir.exists():
+        shutil.rmtree(job_dir, ignore_errors=True)
+
+
+async def cleanup_loop():
+    """Background task: delete job dirs older than MAX_AGE_SECONDS."""
+    while True:
+        await asyncio.sleep(CLEANUP_INTERVAL)
+        try:
+            if not BASE_DIR.exists():
+                continue
+            now = time.time()
+            for entry in BASE_DIR.iterdir():
+                if not entry.is_dir():
+                    continue
+                marker = entry / ".created"
+                if marker.exists():
+                    created = float(marker.read_text().strip())
+                    if now - created > MAX_AGE_SECONDS:
+                        shutil.rmtree(entry, ignore_errors=True)
+                else:
+                    # No marker — use mtime
+                    if now - entry.stat().st_mtime > MAX_AGE_SECONDS:
+                        shutil.rmtree(entry, ignore_errors=True)
+        except Exception:
+            pass

backend/main.py

@@ -0,0 +1,271 @@
+import asyncio
+import io
+import mimetypes
+import zipfile
+from pathlib import Path
+from typing import Literal
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from sse_starlette.sse import EventSourceResponse
+
+from backend import file_manager
+from backend.source_import import SourceImportError, import_source
+from backend.task_queue import enqueue_job, get_job_progress, worker_loop, jobs
+
+import json
+
+app = FastAPI(title="Stem Separator")
+
+MAX_UPLOAD_SIZE = 100 * 1024 * 1024  # 100MB
+EXAMPLE_NAME = "default"
+EXAMPLE_DIR = Path(__file__).parent / "examples" / EXAMPLE_NAME
+EXAMPLE_ORIGINAL_FILE = "original.mp3"
+EXAMPLE_STEM_FILES = {
+    "Vocals": "Vocals.mp3",
+    "Drums": "Drums.mp3",
+    "Bass": "Bass.mp3",
+    "Guitar": "Guitar.mp3",
+    "Piano": "Piano.mp3",
+    "Other": "Other.mp3",
+}
+
+
+# --- Startup / Shutdown ---
+
+@app.on_event("startup")
+async def startup():
+    asyncio.create_task(worker_loop())
+    asyncio.create_task(file_manager.cleanup_loop())
+
+
+# --- API Routes ---
+
+@app.post("/api/upload")
+async def upload_file(file: UploadFile = File(...)):
+    content = await file.read()
+    if len(content) > MAX_UPLOAD_SIZE:
+        raise HTTPException(413, "File too large (max 100MB)")
+
+    allowed_ext = {".wav", ".mp3", ".flac", ".ogg", ".m4a", ".aac", ".wma", ".opus"}
+    ext = Path(file.filename or "file.wav").suffix.lower()
+    if ext not in allowed_ext:
+        raise HTTPException(400, f"Unsupported format: {ext}")
+
+    job_id = file_manager.create_job()
+    file_manager.save_upload(job_id, file.filename or "input.wav", content)
+
+    return {"job_id": job_id, "filename": file.filename}
+
+
+class SeparateRequest(BaseModel):
+    job_id: str
+    stems: list[str]
+    output_format: Literal["wav", "mp3", "aac"] = "wav"
+
+
+class ImportUrlRequest(BaseModel):
+    url: str
+
+
+@app.post("/api/separate")
+async def separate(req: SeparateRequest):
+    job_dir = file_manager.get_job_dir(req.job_id)
+    if not job_dir.exists():
+        raise HTTPException(404, "Job not found")
+
+    valid_stems = {"Vocals", "Drums", "Bass", "Guitar", "Piano", "Other"}
+    requested = [s for s in req.stems if s in valid_stems]
+    if not requested:
+        raise HTTPException(400, "No valid stems selected")
+
+    ok = await enqueue_job(req.job_id, requested, req.output_format)
+    if not ok:
+        raise HTTPException(429, "Queue full, try again later")
+
+    return {"status": "queued", "job_id": req.job_id}
+
+
+@app.post("/api/import-url")
+async def import_url(req: ImportUrlRequest):
+    try:
+        imported = await asyncio.to_thread(import_source, req.url)
+    except SourceImportError as exc:
+        raise HTTPException(400, str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(500, f"Failed to import source: {exc}") from exc
+
+    return {
+        "job_id": imported.job_id,
+        "filename": imported.filename,
+        "source_url": imported.source_url,
+        "resolved_url": imported.resolved_url,
+        "title": imported.title,
+        "platform": imported.platform,
+    }
+
+
+@app.get("/api/progress/{job_id}")
+async def progress_stream(job_id: str):
+    async def event_generator():
+        last_sent = None
+        while True:
+            prog = get_job_progress(job_id)
+            if prog is None:
+                yield {"data": json.dumps({"state": "unknown", "progress": 0, "message": "Job not found"})}
+                return
+
+            current = {
+                "state": prog.state,
+                "progress": prog.progress,
+                "message": prog.message,
+            }
+            if prog.stems is not None:
+                current["stems"] = prog.stems
+            if prog.error is not None:
+                current["error"] = prog.error
+
+            # Only send if changed
+            current_json = json.dumps(current)
+            if current_json != last_sent:
+                yield {"data": current_json}
+                last_sent = current_json
+
+            if prog.state in ("done", "error"):
+                return
+
+            await asyncio.sleep(0.3)
+
+    return EventSourceResponse(event_generator(), ping=10)
+
+
+@app.get("/api/audio/{job_id}/{filename}")
+async def serve_audio(job_id: str, filename: str):
+    path = file_manager.get_file_path(job_id, filename)
+    if path is None:
+        raise HTTPException(404, "File not found")
+    return build_file_response(path, inline=True)
+
+
+@app.get("/api/download/{job_id}/all")
+async def download_all(job_id: str):
+    stems = file_manager.list_stem_files(job_id)
+    if not stems:
+        raise HTTPException(404, "No stems found")
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for stem_name, filename in stems.items():
+            filepath = file_manager.get_file_path(job_id, filename)
+            if filepath and filepath.exists():
+                zf.write(filepath, filename)
+    buf.seek(0)
+
+    return StreamingResponse(
+        buf,
+        media_type="application/zip",
+        headers={"Content-Disposition": "attachment; filename=stems.zip"},
+    )
+
+
+@app.get("/api/download/{job_id}/{filename}")
+async def download_stem(job_id: str, filename: str):
+    path = file_manager.get_file_path(job_id, filename)
+    if path is None:
+        raise HTTPException(404, "File not found")
+    return build_file_response(path, download_name=filename)
+
+
+@app.delete("/api/job/{job_id}")
+async def delete_job(job_id: str):
+    file_manager.delete_job(job_id)
+    jobs.pop(job_id, None)
+    return {"status": "deleted"}
+
+
+@app.get("/api/examples/default")
+async def get_example_output():
+    original_path = get_example_file(EXAMPLE_ORIGINAL_FILE, allow_original=True)
+    stems = []
+    for stem_name, filename in EXAMPLE_STEM_FILES.items():
+        stem_path = get_example_file(filename)
+        stems.append(
+            {
+                "name": stem_name,
+                "filename": stem_path.name,
+                "audioUrl": f"/api/examples/{EXAMPLE_NAME}/audio/{stem_path.name}",
+                "downloadUrl": f"/api/examples/{EXAMPLE_NAME}/download/{stem_path.name}",
+            }
+        )
+
+    return {
+        "original": {
+            "filename": original_path.name,
+            "audioUrl": f"/api/examples/{EXAMPLE_NAME}/audio/{original_path.name}",
+        },
+        "stems": stems,
+        "downloadAllUrl": f"/api/examples/{EXAMPLE_NAME}/download/all",
+    }
+
+
+@app.get("/api/examples/default/audio/{filename}")
+async def serve_example_audio(filename: str):
+    path = get_example_file(filename, allow_original=True)
+    return build_file_response(path, inline=True)
+
+
+@app.get("/api/examples/default/download/all")
+async def download_all_example_stems():
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for filename in EXAMPLE_STEM_FILES.values():
+            path = get_example_file(filename)
+            zf.write(path, path.name)
+    buf.seek(0)
+
+    return StreamingResponse(
+        buf,
+        media_type="application/zip",
+        headers={"Content-Disposition": "attachment; filename=example-stems.zip"},
+    )
+
+
+@app.get("/api/examples/default/download/{filename}")
+async def download_example_file(filename: str):
+    path = get_example_file(filename)
+    return build_file_response(path, download_name=path.name)
+
+
+# --- Static Files (React build) - MUST be last ---
+
+frontend_dist = Path(__file__).parent.parent / "frontend" / "dist"
+if frontend_dist.exists():
+    app.mount("/", StaticFiles(directory=str(frontend_dist), html=True), name="frontend")
+
+
+def build_file_response(path: Path, inline: bool = False, download_name: str | None = None) -> FileResponse:
+    media_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+    headers = {"Accept-Ranges": "bytes"}
+    if download_name is not None:
+        headers["Content-Disposition"] = f'attachment; filename="{download_name}"'
+    elif inline:
+        headers["Content-Disposition"] = f'inline; filename="{path.name}"'
+
+    return FileResponse(path, media_type=media_type, headers=headers)
+
+
+def get_example_file(filename: str, allow_original: bool = False) -> Path:
+    valid_files = set(EXAMPLE_STEM_FILES.values())
+    if allow_original:
+        valid_files.add(EXAMPLE_ORIGINAL_FILE)
+
+    if filename not in valid_files:
+        raise HTTPException(404, "Example file not found")
+
+    path = EXAMPLE_DIR / filename
+    if not path.exists():
+        raise HTTPException(404, f"Missing example asset: {filename}")
+
+    return path

backend/requirements.txt

@@ -0,0 +1,11 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
+sse-starlette>=1.8.0
+audio-separator[cpu]>=0.17.0
+huggingface_hub>=0.20.0
+pydub>=0.25.1
+aiofiles>=23.2.1
+soundfile>=0.12.0
+torchaudio
+yt-dlp>=2025.1.15

backend/separator.py

@@ -0,0 +1,248 @@
+import logging
+import os
+from typing import Callable
+
+import numpy as np
+import soundfile as sf
+import torch
+import torchaudio
+import yaml
+from pydub import AudioSegment
+from huggingface_hub import hf_hub_download
+from audio_separator.separator.uvr_lib_v5.roformer.bs_roformer import BSRoformer
+
+logger = logging.getLogger(__name__)
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+if DEVICE.type == "cpu":
+    cpu_count = os.cpu_count() or 1
+    torch.set_num_threads(cpu_count)
+    torch.set_num_interop_threads(max(1, cpu_count // 2))
+    logger.info(f"CPU mode: set torch threads={cpu_count}, interop={max(1, cpu_count // 2)}")
+
+MODEL_REPO = "jarredou/BS-ROFO-SW-Fixed"
+MODEL_FILENAME = "BS-Rofo-SW-Fixed.ckpt"
+MODEL_CONFIG = "BS-Rofo-SW-Fixed.yaml"
+MODEL_DIR = "/tmp/models"
+
+# Stem order matches the model's training config
+STEM_ORDER = ["bass", "drums", "other", "vocals", "guitar", "piano"]
+STEM_NAME_MAP = {
+    "bass": "Bass",
+    "drums": "Drums",
+    "other": "Other",
+    "vocals": "Vocals",
+    "guitar": "Guitar",
+    "piano": "Piano",
+}
+
+
+class StemSeparatorService:
+    _instance = None
+    _model_loaded = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def load_model(self):
+        if self._model_loaded:
+            return
+
+        os.makedirs(MODEL_DIR, exist_ok=True)
+        logger.info(f"Downloading model from HF Hub: {MODEL_REPO}")
+
+        hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILENAME, local_dir=MODEL_DIR)
+        hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_CONFIG, local_dir=MODEL_DIR)
+
+        # Parse config
+        with open(os.path.join(MODEL_DIR, MODEL_CONFIG)) as f:
+            config = yaml.load(f, Loader=yaml.FullLoader)
+
+        model_cfg = config["model"]
+        audio_cfg = config.get("audio", {})
+        inference_cfg = config.get("inference", {})
+
+        self.sample_rate = audio_cfg.get("sample_rate", 44100)
+        self.chunk_size = audio_cfg.get("chunk_size", 588800)
+        self.num_overlap = inference_cfg.get("num_overlap", 2)
+
+        # Use flash_attn only on CUDA where it's supported
+        use_flash = DEVICE.type == "cuda"
+
+        # Create model directly — bypass audio-separator's Separator wrapper entirely
+        self.model = BSRoformer(
+            dim=model_cfg["dim"],
+            depth=model_cfg["depth"],
+            stereo=model_cfg.get("stereo", True),
+            num_stems=model_cfg.get("num_stems", 6),
+            time_transformer_depth=model_cfg.get("time_transformer_depth", 1),
+            freq_transformer_depth=model_cfg.get("freq_transformer_depth", 1),
+            linear_transformer_depth=model_cfg.get("linear_transformer_depth", 0),
+            freqs_per_bands=tuple(model_cfg["freqs_per_bands"]),
+            dim_head=model_cfg.get("dim_head", 64),
+            heads=model_cfg.get("heads", 8),
+            attn_dropout=model_cfg.get("attn_dropout", 0.1),
+            ff_dropout=model_cfg.get("ff_dropout", 0.1),
+            flash_attn=use_flash,
+            dim_freqs_in=model_cfg.get("dim_freqs_in", 1025),
+            stft_n_fft=model_cfg.get("stft_n_fft", 2048),
+            stft_hop_length=model_cfg.get("stft_hop_length", 512),
+            stft_win_length=model_cfg.get("stft_win_length", 2048),
+            stft_normalized=model_cfg.get("stft_normalized", False),
+            mask_estimator_depth=model_cfg.get("mask_estimator_depth", 2),
+            multi_stft_resolution_loss_weight=model_cfg.get("multi_stft_resolution_loss_weight", 1.0),
+            multi_stft_resolutions_window_sizes=tuple(
+                model_cfg.get("multi_stft_resolutions_window_sizes", (4096, 2048, 1024, 512, 256))
+            ),
+            multi_stft_hop_size=model_cfg.get("multi_stft_hop_size", 147),
+            multi_stft_normalized=model_cfg.get("multi_stft_normalized", False),
+            mlp_expansion_factor=model_cfg.get("mlp_expansion_factor", 4),
+            use_torch_checkpoint=model_cfg.get("use_torch_checkpoint", False),
+            skip_connection=model_cfg.get("skip_connection", False),
+        )
+
+        # Load checkpoint weights
+        ckpt_path = os.path.join(MODEL_DIR, MODEL_FILENAME)
+        try:
+            state_dict = torch.load(ckpt_path, map_location=DEVICE, weights_only=True)
+        except TypeError:
+            state_dict = torch.load(ckpt_path, map_location=DEVICE)
+
+        if isinstance(state_dict, dict) and "state_dict" in state_dict:
+            state_dict = state_dict["state_dict"]
+        elif isinstance(state_dict, dict) and "model" in state_dict:
+            state_dict = state_dict["model"]
+
+        self.model.load_state_dict(state_dict)
+        self.model.to(DEVICE)
+        self.model.eval()
+
+        logger.info(f"BS-RoFormer model loaded successfully on {DEVICE}")
+        self._model_loaded = True
+
+    def _process_audio(self, audio_tensor: torch.Tensor, progress_callback) -> torch.Tensor:
+        """Run inference with chunking and overlap-add."""
+        chunk_size = self.chunk_size
+        step = chunk_size // self.num_overlap
+
+        channels, total_samples = audio_tensor.shape
+        num_stems = 6
+
+        # Pad so we cover the full audio
+        pad_needed = max(0, chunk_size - total_samples)
+        if total_samples > chunk_size:
+            remainder = (total_samples - chunk_size) % step
+            if remainder != 0:
+                pad_needed = step - remainder
+
+        if pad_needed > 0:
+            audio_tensor = torch.nn.functional.pad(audio_tensor, (0, pad_needed))
+
+        padded_len = audio_tensor.shape[1]
+
+        # Move input to device
+        audio_tensor = audio_tensor.to(DEVICE)
+
+        # Output accumulators (keep on CPU to save GPU memory)
+        result = torch.zeros(num_stems, channels, padded_len)
+        weight = torch.zeros(padded_len)
+
+        # Hann window for smooth crossfading
+        window = torch.hann_window(chunk_size, device=DEVICE)
+
+        # Build chunk positions
+        starts = list(range(0, padded_len - chunk_size + 1, step))
+        total_chunks = len(starts)
+
+        for i, start in enumerate(starts):
+            chunk = audio_tensor[:, start : start + chunk_size]
+
+            with torch.no_grad():
+                # BSRoformer: (batch, channels, time) -> (batch, stems, channels, time)
+                output = self.model(chunk.unsqueeze(0))
+
+            output = output.squeeze(0)  # (stems, channels, time)
+
+            # Move output to CPU for accumulation
+            output_cpu = output.cpu()
+            window_cpu = window.cpu()
+            result[:, :, start : start + chunk_size] += output_cpu * window_cpu
+            weight[start : start + chunk_size] += window_cpu
+
+            frac = (i + 1) / total_chunks
+            progress_callback("separating", 0.2 + frac * 0.7)
+
+        # Normalize by overlap weight
+        result = result / weight.clamp(min=1e-8).unsqueeze(0).unsqueeze(0)
+
+        # Remove padding
+        return result[:, :, :total_samples]
+
+    def separate(
+        self,
+        input_path: str,
+        output_dir: str,
+        stems: list[str],
+        output_format: str,
+        progress_callback: Callable[[str, float], None],
+    ) -> dict[str, str]:
+        progress_callback("loading_model", 0.05)
+        self.load_model()
+
+        progress_callback("separating", 0.15)
+
+        # Load audio
+        audio, sr = sf.read(input_path)
+        if audio.ndim == 1:
+            audio = np.stack([audio, audio], axis=1)  # Mono to stereo
+
+        audio_tensor = torch.tensor(audio.T, dtype=torch.float32)  # (channels, samples)
+
+        # Resample if needed
+        if sr != self.sample_rate:
+            resampler = torchaudio.transforms.Resample(sr, self.sample_rate)
+            audio_tensor = resampler(audio_tensor)
+
+        # Run inference
+        separated = self._process_audio(audio_tensor, progress_callback)
+
+        progress_callback("finalizing", 0.92)
+
+        # Save requested stems
+        result: dict[str, str] = {}
+        for i, stem_key in enumerate(STEM_ORDER):
+            canonical = STEM_NAME_MAP[stem_key]
+            if canonical in stems:
+                stem_audio = separated[i].numpy().T  # (samples, channels)
+                # Clip to prevent clipping artifacts
+                stem_audio = np.clip(stem_audio, -1.0, 1.0)
+                clean_name = f"{canonical}.{output_format}"
+                out_path = os.path.join(output_dir, clean_name)
+                self._write_output(out_path, stem_audio, output_format)
+                result[canonical] = clean_name
+
+        progress_callback("done", 1.0)
+        return result
+
+    def _write_output(self, output_path: str, stem_audio: np.ndarray, output_format: str):
+        if output_format == "wav":
+            sf.write(output_path, stem_audio, self.sample_rate, subtype="FLOAT")
+            return
+
+        pcm = (stem_audio * 32767.0).astype(np.int16)
+        segment = AudioSegment(
+            data=pcm.tobytes(),
+            sample_width=2,
+            frame_rate=self.sample_rate,
+            channels=pcm.shape[1] if pcm.ndim > 1 else 1,
+        )
+
+        export_format = "mp3" if output_format == "mp3" else "adts"
+        export_kwargs = {"format": export_format}
+        if output_format in {"mp3", "aac"}:
+            export_kwargs["bitrate"] = "192k"
+        segment.export(output_path, **export_kwargs)

backend/source_import.py

@@ -0,0 +1,293 @@
+import json
+import re
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import parse_qs, quote, urlparse
+from urllib.request import Request, urlopen
+
+from yt_dlp import YoutubeDL
+
+from backend import file_manager
+
+
+USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/122.0.0.0 Safari/537.36"
+)
+
+
+@dataclass
+class ImportedTrack:
+    job_id: str
+    filename: str
+    source_url: str
+    resolved_url: str | None
+    title: str
+    platform: str
+
+
+class SourceImportError(Exception):
+    pass
+
+
+def import_source(url: str) -> ImportedTrack:
+    normalized_url = normalize_url(url)
+    platform = classify_platform(normalized_url)
+    job_id = file_manager.create_job()
+    job_dir = file_manager.get_job_dir(job_id)
+
+    try:
+        if platform in {"youtube", "ytmusic"}:
+            title, display_filename = download_youtube_source(
+                normalized_url,
+                job_dir,
+            )
+            metadata = {
+                "source_kind": platform,
+                "source_url": normalized_url,
+                "resolved_url": normalized_url,
+                "title": title,
+                "filename": display_filename,
+            }
+            file_manager.save_job_metadata(job_id, metadata)
+            return ImportedTrack(
+                job_id=job_id,
+                filename=display_filename,
+                source_url=normalized_url,
+                resolved_url=normalized_url,
+                title=title,
+                platform=platform,
+            )
+
+        track_title, primary_artist = fetch_spotify_track_metadata(normalized_url)
+        search_query = f"{track_title} {primary_artist} audio"
+        resolved_url = resolve_youtube_search(search_query)
+        title, display_filename = download_youtube_source(
+            resolved_url,
+            job_dir,
+            title_hint=f"{track_title} - {primary_artist}",
+        )
+        metadata = {
+            "source_kind": "spotify",
+            "source_url": normalized_url,
+            "resolved_url": resolved_url,
+            "title": title,
+            "filename": display_filename,
+            "spotify_track_title": track_title,
+            "spotify_primary_artist": primary_artist,
+        }
+        file_manager.save_job_metadata(job_id, metadata)
+        return ImportedTrack(
+            job_id=job_id,
+            filename=display_filename,
+            source_url=normalized_url,
+            resolved_url=resolved_url,
+            title=title,
+            platform="spotify",
+        )
+    except Exception:
+        file_manager.delete_job(job_id)
+        raise
+
+
+def normalize_url(url: str) -> str:
+    value = url.strip()
+    if not value:
+        raise SourceImportError("Paste a YouTube, YouTube Music, or Spotify track link")
+    return value
+
+
+def classify_platform(url: str) -> str:
+    parsed = urlparse(url)
+    host = parsed.netloc.lower().removeprefix("www.")
+    path = parsed.path
+    query = parse_qs(parsed.query)
+
+    if host in {"youtube.com", "m.youtube.com", "youtu.be"}:
+        if "list" in query:
+            raise SourceImportError("Playlist links are not supported yet")
+        if host == "youtu.be":
+            return "youtube"
+        if path.startswith("/watch") or path.startswith("/shorts/"):
+            return "youtube"
+        if path.startswith("/playlist") or path.startswith("/channel/") or path.startswith("/@"):
+            raise SourceImportError("Only single YouTube video links are supported")
+        raise SourceImportError("Unsupported YouTube link")
+
+    if host == "music.youtube.com":
+        if "list" in query:
+            raise SourceImportError("Playlist links are not supported yet")
+        if path.startswith("/watch"):
+            return "ytmusic"
+        raise SourceImportError("Only single YouTube Music track links are supported")
+
+    if host == "open.spotify.com":
+        parts = [part for part in path.split("/") if part]
+        if len(parts) >= 2 and parts[0] == "track":
+            return "spotify"
+        if parts and parts[0] in {"album", "playlist", "artist", "show", "episode"}:
+            raise SourceImportError("Only single Spotify track links are supported")
+        raise SourceImportError("Unsupported Spotify link")
+
+    raise SourceImportError("Unsupported link. Use YouTube, YouTube Music, or Spotify track URLs")
+
+
+def download_youtube_source(
+    source_url: str,
+    job_dir: Path,
+    title_hint: str | None = None,
+) -> tuple[str, str]:
+    temp_dir = Path(tempfile.mkdtemp(prefix="import-", dir=str(job_dir)))
+
+    try:
+        options = {
+            "format": "bestaudio/best",
+            "paths": {"home": str(temp_dir)},
+            "outtmpl": {"default": "downloaded.%(ext)s"},
+            "quiet": True,
+            "no_warnings": True,
+            "noplaylist": True,
+            "extract_flat": False,
+            "postprocessors": [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": "wav",
+                }
+            ],
+        }
+
+        with YoutubeDL(options) as ydl:
+            info = ydl.extract_info(source_url, download=True)
+
+        output_path = find_downloaded_audio(temp_dir)
+        content = output_path.read_bytes()
+        display_title = sanitize_title(title_hint or info.get("title") or output_path.stem)
+        display_filename = f"{display_title}.wav"
+        file_manager.save_imported_audio(job_dir.name, display_filename, content)
+        return display_title, display_filename
+    except SourceImportError:
+        raise
+    except Exception as exc:
+        raise SourceImportError(f"Failed to download source audio: {exc}") from exc
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def find_downloaded_audio(temp_dir: Path) -> Path:
+    audio_files = sorted(
+        [
+            path
+            for path in temp_dir.iterdir()
+            if path.is_file()
+            and path.suffix.lower() in {".wav", ".mp3", ".m4a", ".aac", ".flac", ".opus", ".ogg"}
+        ],
+        key=lambda path: path.stat().st_mtime,
+        reverse=True,
+    )
+    if not audio_files:
+        raise SourceImportError("Downloaded source did not produce a playable audio file")
+    return audio_files[0]
+
+
+def fetch_spotify_track_metadata(url: str) -> tuple[str, str]:
+    oembed_url = f"https://open.spotify.com/oembed?url={quote(url, safe='')}"
+    request = Request(oembed_url, headers={"User-Agent": USER_AGENT})
+
+    try:
+        with urlopen(request, timeout=20) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+        title = payload.get("title", "").strip()
+        artist = payload.get("author_name", "").strip()
+        if title and artist:
+            return title, artist
+    except Exception:
+        pass
+
+    html = fetch_text(url)
+    title = first_match(
+        html,
+        [
+            r'<meta property="og:title" content="([^"]+)"',
+            r"<title>([^<]+)</title>",
+        ],
+    )
+    artist = first_match(
+        html,
+        [
+            r'<meta name="music:musician_description" content="([^"]+)"',
+            r'"artists"\s*:\s*\[\s*\{\s*"name"\s*:\s*"([^"]+)"',
+            r'"byArtist"\s*:\s*\{\s*"name"\s*:\s*"([^"]+)"',
+        ],
+    )
+
+    if not title or not artist:
+        raise SourceImportError("Could not read Spotify track metadata from the public page")
+
+    return clean_spotify_title(title), artist.strip()
+
+
+def resolve_youtube_search(query: str) -> str:
+    options = {
+        "quiet": True,
+        "no_warnings": True,
+        "extract_flat": "in_playlist",
+        "noplaylist": True,
+    }
+
+    try:
+        with YoutubeDL(options) as ydl:
+            info = ydl.extract_info(f"ytsearch1:{query}", download=False)
+    except Exception as exc:
+        raise SourceImportError(f"Failed to search YouTube for a Spotify track match: {exc}") from exc
+
+    entries = info.get("entries") or []
+    if not entries:
+        raise SourceImportError("No matching YouTube source was found for this Spotify track")
+
+    entry = entries[0]
+    resolved_url = entry.get("webpage_url") or entry.get("url")
+    if resolved_url and not str(resolved_url).startswith("http"):
+        video_id = entry.get("id") or resolved_url
+        resolved_url = f"https://www.youtube.com/watch?v={video_id}"
+    if not resolved_url:
+        raise SourceImportError("Resolved YouTube match did not include a downloadable URL")
+    return resolved_url
+
+
+def fetch_text(url: str) -> str:
+    request = Request(url, headers={"User-Agent": USER_AGENT})
+    with urlopen(request, timeout=20) as response:
+        return response.read().decode("utf-8", errors="ignore")
+
+
+def first_match(text: str, patterns: list[str]) -> str | None:
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            return unescape_html(match.group(1))
+    return None
+
+
+def sanitize_title(value: str) -> str:
+    clean = re.sub(r"[\\/:*?\"<>|]+", " ", value)
+    clean = re.sub(r"\s+", " ", clean).strip().strip(".")
+    return clean[:120] or "Imported Track"
+
+
+def clean_spotify_title(value: str) -> str:
+    title = value.replace(" | Spotify", "").strip()
+    if " - song and lyrics by " in title.lower():
+        title = re.split(r"\s+-\s+song and lyrics by\s+", title, flags=re.IGNORECASE)[0]
+    return title.strip()
+
+
+def unescape_html(value: str) -> str:
+    return (
+        value.replace("&amp;", "&")
+        .replace("&quot;", '"')
+        .replace("&#x27;", "'")
+        .replace("&#39;", "'")
+    )

backend/task_queue.py

@@ -0,0 +1,100 @@
+import asyncio
+from dataclasses import dataclass
+
+from backend.separator import StemSeparatorService
+from backend import file_manager
+
+
+@dataclass
+class JobProgress:
+    state: str = "queued"
+    progress: float = 0.0
+    message: str = "Waiting in queue..."
+    stems: dict[str, str] | None = None
+    error: str | None = None
+
+
+# Shared state
+jobs: dict[str, JobProgress] = {}
+_queue: asyncio.Queue | None = None
+
+
+def get_queue() -> asyncio.Queue:
+    global _queue
+    if _queue is None:
+        _queue = asyncio.Queue(maxsize=5)
+    return _queue
+
+
+def get_job_progress(job_id: str) -> JobProgress | None:
+    return jobs.get(job_id)
+
+
+async def enqueue_job(job_id: str, stems: list[str], output_format: str) -> bool:
+    """Enqueue a separation job. Returns False if queue is full."""
+    q = get_queue()
+    if q.full():
+        return False
+    jobs[job_id] = JobProgress()
+    await q.put((job_id, stems, output_format))
+    return True
+
+
+async def worker_loop():
+    """Single worker that processes separation jobs sequentially."""
+    separator = StemSeparatorService()
+    q = get_queue()
+
+    while True:
+        job_id, stems, output_format = await q.get()
+        try:
+            progress = jobs.get(job_id)
+            if progress is None:
+                progress = JobProgress()
+                jobs[job_id] = progress
+
+            def update_progress(state: str, pct: float):
+                progress.state = state
+                progress.progress = pct
+                messages = {
+                    "loading_model": "Loading BS-RoFormer model...",
+                    "separating": "Separating stems...",
+                    "finalizing": "Finalizing output files...",
+                    "done": "Separation complete!",
+                }
+                progress.message = messages.get(state, f"{state}...")
+
+            input_file = file_manager.get_input_file(job_id)
+            if input_file is None:
+                progress.state = "error"
+                progress.error = "Input file not found"
+                progress.message = "Error: input file not found"
+                continue
+
+            output_dir = str(file_manager.get_output_dir(job_id))
+
+            # Run separation in a thread to avoid blocking the event loop
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                separator.separate,
+                str(input_file),
+                output_dir,
+                stems,
+                output_format,
+                update_progress,
+            )
+
+            progress.state = "done"
+            progress.progress = 1.0
+            progress.message = "Separation complete!"
+            progress.stems = result
+
+        except Exception as e:
+            progress = jobs.get(job_id, JobProgress())
+            progress.state = "error"
+            progress.error = str(e)
+            progress.message = f"Error: {e}"
+            jobs[job_id] = progress
+        finally:
+            q.task_done()

frontend/dist/assets/index-P-4oQdbx.css

@@ -0,0 +1 @@
+/*! tailwindcss v4.2.1 | MIT License | https://tailwindcss.com */@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-font-weight:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-duration:initial;--tw-ease:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--font-mono:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;--color-red-400:oklch(70.4% .191 22.216);--color-red-500:oklch(63.7% .237 25.331);--color-pink-500:oklch(65.6% .241 354.308);--color-white:#fff;--spacing:.25rem;--container-3xl:48rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--radius-lg:.5rem;--radius-xl:.75rem;--ease-out:cubic-bezier(0, 0, .2, 1);--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-bg-primary:#0a0a0f;--color-bg-secondary:#13131a;--color-bg-card:#1a1a24;--color-bg-hover:#252530;--color-text-primary:#e8e8ef;--color-text-secondary:#8888a0;--color-accent:#7c3aed;--color-accent-hover:#6d28d9;--color-border:#2a2a38}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;-moz-tab-size:4;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){-webkit-appearance:button;-moz-appearance:button;appearance:button}::file-selector-button{-webkit-appearance:button;-moz-appearance:button;appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}}@layer components;@layer utilities{.pointer-events-none{pointer-events:none}.relative{position:relative}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.mx-auto{margin-inline:auto}.mt-1{margin-top:calc(var(--spacing) * 1)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline-flex{display:inline-flex}.h-2{height:calc(var(--spacing) * 2)}.h-2\.5{height:calc(var(--spacing) * 2.5)}.h-3{height:calc(var(--spacing) * 3)}.h-3\.5{height:calc(var(--spacing) * 3.5)}.h-4{height:calc(var(--spacing) * 4)}.h-5{height:calc(var(--spacing) * 5)}.h-8{height:calc(var(--spacing) * 8)}.h-10{height:calc(var(--spacing) * 10)}.h-12{height:calc(var(--spacing) * 12)}.h-full{height:100%}.min-h-screen{min-height:100vh}.w-2\.5{width:calc(var(--spacing) * 2.5)}.w-3{width:calc(var(--spacing) * 3)}.w-3\.5{width:calc(var(--spacing) * 3.5)}.w-4{width:calc(var(--spacing) * 4)}.w-5{width:calc(var(--spacing) * 5)}.w-8{width:calc(var(--spacing) * 8)}.w-10{width:calc(var(--spacing) * 10)}.w-12{width:calc(var(--spacing) * 12)}.w-\[85px\]{width:85px}.w-full{width:100%}.max-w-3xl{max-width:var(--container-3xl)}.min-w-0{min-width:calc(var(--spacing) * 0)}.flex-shrink-0{flex-shrink:0}.flex-grow{flex-grow:1}.cursor-not-allowed{cursor:not-allowed}.cursor-pointer{cursor:pointer}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.flex-col{flex-direction:column}.items-center{align-items:center}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)))}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-xl{border-radius:var(--radius-xl)}.border{border-style:var(--tw-border-style);border-width:1px}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-dashed{--tw-border-style:dashed;border-style:dashed}.border-accent{border-color:var(--color-accent)}.border-border{border-color:var(--color-border)}.border-red-500\/30{border-color:#fb2c364d}@supports (color:color-mix(in lab,red,red)){.border-red-500\/30{border-color:color-mix(in oklab,var(--color-red-500) 30%,transparent)}}.border-transparent{border-color:#0000}.bg-accent{background-color:var(--color-accent)}.bg-accent\/10{background-color:#7c3aed1a}@supports (color:color-mix(in lab,red,red)){.bg-accent\/10{background-color:color-mix(in oklab,var(--color-accent) 10%,transparent)}}.bg-bg-card{background-color:var(--color-bg-card)}.bg-bg-hover{background-color:var(--color-bg-hover)}.bg-bg-primary{background-color:var(--color-bg-primary)}.bg-red-500\/10{background-color:#fb2c361a}@supports (color:color-mix(in lab,red,red)){.bg-red-500\/10{background-color:color-mix(in oklab,var(--color-red-500) 10%,transparent)}}.bg-gradient-to-r{--tw-gradient-position:to right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-accent{--tw-gradient-from:var(--color-accent);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.to-pink-500{--tw-gradient-to:var(--color-pink-500);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.bg-clip-text{-webkit-background-clip:text;background-clip:text}.p-3{padding:calc(var(--spacing) * 3)}.p-4{padding:calc(var(--spacing) * 4)}.p-8{padding:calc(var(--spacing) * 8)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.px-6{padding-inline:calc(var(--spacing) * 6)}.py-1\.5{padding-block:calc(var(--spacing) * 1.5)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-3{padding-block:calc(var(--spacing) * 3)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.text-center{text-align:center}.text-right{text-align:right}.font-mono{font-family:var(--font-mono)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.text-accent{color:var(--color-accent)}.text-red-400{color:var(--color-red-400)}.text-text-primary{color:var(--color-text-primary)}.text-text-secondary{color:var(--color-text-secondary)}.text-transparent{color:#0000}.text-white{color:var(--color-white)}.opacity-50{opacity:.5}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-accent\/25{--tw-shadow-color:#7c3aed40}@supports (color:color-mix(in lab,red,red)){.shadow-accent\/25{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-accent) 25%, transparent) var(--tw-shadow-alpha), transparent)}}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}@media(hover:hover){.hover\:border-text-secondary:hover{border-color:var(--color-text-secondary)}.hover\:bg-accent-hover:hover{background-color:var(--color-accent-hover)}.hover\:bg-bg-hover:hover{background-color:var(--color-bg-hover)}.hover\:bg-bg-hover\/50:hover{background-color:#25253080}@supports (color:color-mix(in lab,red,red)){.hover\:bg-bg-hover\/50:hover{background-color:color-mix(in oklab,var(--color-bg-hover) 50%,transparent)}}.hover\:text-accent-hover:hover{color:var(--color-accent-hover)}.hover\:text-text-primary:hover{color:var(--color-text-primary)}.hover\:shadow-accent\/40:hover{--tw-shadow-color:#7c3aed66}@supports (color:color-mix(in lab,red,red)){.hover\:shadow-accent\/40:hover{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-accent) 40%, transparent) var(--tw-shadow-alpha), transparent)}}}.active\:scale-\[0\.98\]:active{scale:.98}.disabled\:opacity-30:disabled{opacity:.3}.disabled\:opacity-50:disabled{opacity:.5}@media(min-width:40rem){.sm\:w-24{width:calc(var(--spacing) * 24)}.sm\:flex-row{flex-direction:row}.sm\:items-center{align-items:center}.sm\:gap-4{gap:calc(var(--spacing) * 4)}}@media(min-width:48rem){.md\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.md\:p-4{padding:calc(var(--spacing) * 4)}.md\:p-5{padding:calc(var(--spacing) * 5)}.md\:p-12{padding:calc(var(--spacing) * 12)}.md\:py-12{padding-block:calc(var(--spacing) * 12)}.md\:text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.md\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}}}body{background-color:var(--color-bg-primary);color:var(--color-text-primary);min-height:100vh;margin:0;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif}*{box-sizing:border-box}::-webkit-scrollbar{width:6px}::-webkit-scrollbar-track{background:var(--color-bg-secondary)}::-webkit-scrollbar-thumb{background:var(--color-border);border-radius:3px}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"<length-percentage>";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"<length-percentage>";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"<length-percentage>";inherits:false;initial-value:100%}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}

frontend/dist/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Stem Separator</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🎵</text></svg>" />
+    <script type="module" crossorigin src="/assets/index-CiF4mW7R.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-P-4oQdbx.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

frontend/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Stem Separator</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🎵</text></svg>" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/node_modules/.bin/baseline-browser-mapping

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0d5012244d9133cb5851e14e2a4300a067b28f777610d92201495cf56ad383c
+size 423

frontend/node_modules/.bin/baseline-browser-mapping.cmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:546308c1cb7900c7bc19001ca144e8034017372cf204945637b0777fb6e0914d
+size 342

frontend/node_modules/.bin/baseline-browser-mapping.ps1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c329cbf021bcef4808042139875afd4946833e2564a0e92ed8950bd4f7442ed3
+size 873

frontend/node_modules/.bin/browserslist

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54fdec30a2fdafa92270bd5f6f8b469eae04d9d691a0efa5c81e5f9720ce43db
+size 387

frontend/node_modules/.bin/browserslist.cmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4256324c48333044314aba80247152ce152284f6198f073471082263ad68e000
+size 324

frontend/node_modules/.bin/browserslist.ps1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29aadbfb1ce80642e7c4d82a68013b8e22298eabb2b780fcda40e960fd9fe114
+size 801

frontend/node_modules/.bin/esbuild

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:020b954fd13a2c5ee8aabd5a73e24c10a4750099ed5e02f07dc7265c6758a054
+size 387

frontend/node_modules/.bin/esbuild.cmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b00afc3761267058834ab0968f58748f0422efe0eb0321540544770cafbf7a69
+size 324

frontend/node_modules/.bin/esbuild.ps1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a24efc13fb6ef9def6c5aaf7787e7203d0982e2ab8627b64a41eb033945b7f5
+size 801

frontend/node_modules/.bin/jiti

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d520004d5e2263d19e15b4428f84242e88a8b996aa856208a3c3ba6c44f916a2
+size 391

frontend/node_modules/.bin/jiti.cmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b161a3ade2fd9a6ae94bb6c4af14828436bb0f3c32ee0bbfb036d68c2e59083
+size 326

frontend/node_modules/.bin/jiti.ps1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40363e635374e55b3243679de83e59dfa1eaf38f7b5d9837b748cad64d28d32d
+size 809

frontend/node_modules/.bin/jsesc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e602c28ae389059f8432b215bf7cf139ddf94a0115b7d6f407ed7ec44009b8b4
+size 379

frontend/node_modules/.bin/jsesc.cmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b87fd711d42d591a1f58ff7e1ab5853fec23500124199234e067db1ecf3cac1f
+size 320

frontend/node_modules/.bin/jsesc.ps1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1fea8d4906bc84471a56ca344efa060ff05d6d1cc5e924ce80c74a2468e4634
+size 785

frontend/node_modules/.bin/json5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dbbbcf1513aa4adede8edd73bf10cdf666bd2c0ee7fb5b92a9ecc688a278016
+size 381

frontend/node_modules/.bin/json5.cmd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac1c85ef42fd4756851c82bcced541694345d9e5196f36f25fef83d2cb4409cd
+size 321

frontend/node_modules/.bin/json5.ps1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1928bf0cbc643164307fc9b7529a03657bbf58a74e552c1cd241305c6fafa754
+size 789

frontend/node_modules/.bin/nanoid

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49446fa7e9ea1b36b205bab243f2928f1230d8dbeb09881eef1d039149ad3238
+size 391