diff --git a/src/backend/app/main.py b/src/backend/app/main.py
index be880c84..85c74d1e 100644
--- a/src/backend/app/main.py
+++ b/src/backend/app/main.py
@@ -99,3 +99,11 @@ async def lifespan(app: FastAPI):
 from app.routes.ws.state import router as ws_router
 
 app.include_router(ws_router)
+
+from app.routes.http.reverse import router as reverse_router
+
+app.include_router(reverse_router)
+
+from app.routes.ws.reverse import router as ws_reverse_router
+
+app.include_router(ws_reverse_router)
diff --git a/src/backend/app/routes/http/download.py b/src/backend/app/routes/http/download.py
index fe77c9c8..f837154f 100644
--- a/src/backend/app/routes/http/download.py
+++ b/src/backend/app/routes/http/download.py
@@ -13,7 +13,7 @@
 router = APIRouter()
 
 
-@router.get("/download/{key}")
+@router.get("/download/{key:path}")
 async def download_files(
     key: str,
     session: SessionDep,
diff --git a/src/backend/app/routes/http/reverse.py b/src/backend/app/routes/http/reverse.py
new file mode 100644
index 00000000..463d689a
--- /dev/null
+++ b/src/backend/app/routes/http/reverse.py
@@ -0,0 +1,275 @@
+import json
+import uuid
+from datetime import datetime, timezone
+from urllib.parse import quote
+
+from botocore.exceptions import ClientError
+from fastapi import APIRouter, Header, HTTPException, UploadFile, status, Request
+from fastapi.responses import StreamingResponse
+from sqlmodel import col, select
+from types_aiobotocore_s3.type_defs import CompletedPartTypeDef
+
+from app.converter.bytes import ByteSize
+from app.deps import S3Dep, SessionDep
+from app.models.files import File
+from app.schemas.reverse import (
+    AddHostOut,
+    RoomCreate,
+    RoomCreateOut,
+    RoomFileEntry,
+    RoomOut,
+)
+from app.settings import settings
+from app.states.room import RoomState
+from app.states.app import UploadProgress
+from app.tasks.clean_file import delete_expired_file
+from app.tasks.persist_file import persist_file_record
+
+router = APIRouter(prefix="/reverse")
+
+CHUNK_SIZE = ByteSize(mb=8).total_bytes()
+
+
+@router.post("/rooms", status_code=status.HTTP_201_CREATED)
+async def create_room(body: RoomCreate) -> RoomCreateOut:
+    return await RoomState.create(name=body.name, expire_after=body.expire_after)
+
+
+@router.get("/rooms/{room_id}")
+async def get_room(room_id: str) -> RoomOut:
+    room = await RoomState.get(room_id)
+    if room is None:
+        raise HTTPException(status_code=404, detail="Room not found or expired")
+    return room
+
+
+@router.delete("/rooms/{room_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_room(
+    room_id: str,
+    session: SessionDep,
+    x_host_token: str = Header(),
+) -> None:
+    if not await RoomState.verify_host(room_id, x_host_token):
+        raise HTTPException(status_code=403, detail="Invalid host token")
+
+    room = await RoomState.get(room_id)
+    if room is None:
+        raise HTTPException(status_code=404, detail="Room not found or expired")
+
+    # Schedule file cleanup (S3 + DB) via the existing file cleanup task
+    if room.files:
+        keys = [f.key for f in room.files]
+        result = await session.exec(select(File).where(col(File.key).in_(keys)))
+        for file_record in result.all():
+            delete_expired_file.delay(str(file_record.id))
+
+    await RoomState.publish_event(room_id, json.dumps({"type": "room_destroyed"}))
+    await RoomState.delete(room_id)
+
+
+@router.post("/rooms/{room_id}/hosts", status_code=status.HTTP_201_CREATED)
+async def add_host(
+    room_id: str,
+    x_host_token: str = Header(),
+) -> AddHostOut:
+    """An existing host can invite a new host to the room."""
+    if not await RoomState.verify_host(room_id, x_host_token):
+        raise HTTPException(status_code=403, detail="Invalid host token")
+
+    result = await RoomState.add_host(room_id)
+    if result is None:
+        raise HTTPException(status_code=404, detail="Room not found or expired")
+    return result
+
+
+@router.post("/rooms/{room_id}/upload")
+async def upload_file_to_room(
+    room_id: str,
+    file: UploadFile,
+    file: UploadFile,
+    request: Request,
+    s3: S3Dep,
+    x_host_token: str = Header(),
+) -> RoomFileEntry:
+    if not await RoomState.verify_host(room_id, x_host_token):
+        raise HTTPException(status_code=403, detail="Invalid host token")
+
+    room = await RoomState.get(room_id)
+    if room is None:
+        raise HTTPException(status_code=404, detail="Room not found or expired")
+
+    # Check room hasn't expired by time
+    if datetime.now(timezone.utc) > room.expires_at:
+        raise HTTPException(status_code=410, detail="Room has expired")
+
+    # Namespace S3 key under the room
+    file_key = f"rooms/{room_id}/{uuid.uuid7()}"
+    filename = file.filename or str(uuid.uuid7())
+
+    # Track upload progress in global AppState so websockets and other
+    # observers can see in-flight uploads (mirrors upload.py behavior).
+    await UploadProgress.start(upload_key=file_key, filename=filename)
+
+    # Multipart upload to RustFS
+    # Store filename in S3 metadata so the shareable download link works
+    # even after the room expires.
+    resp = await s3.create_multipart_upload(
+        Bucket=settings.RUSTFS_BUCKET_NAME,
+        Key=file_key,
+        ContentType=file.content_type or "application/octet-stream",
+        Metadata={"filename": filename},
+    )
+    upload_id = resp["UploadId"]
+    # boto3 type defs expect a sequence of CompletedPartTypeDef
+    parts: list[CompletedPartTypeDef] = []
+    part_number = 1
+    uploaded_size = 0
+
+    try:
+        while True:
+            chunk = await file.read(CHUNK_SIZE)
+            if not chunk:
+                break
+
+            part_resp = await s3.upload_part(
+                Bucket=settings.RUSTFS_BUCKET_NAME,
+                Key=file_key,
+                UploadId=upload_id,
+                PartNumber=part_number,
+                Body=chunk,
+            )
+            part_entry: CompletedPartTypeDef = {
+                "ETag": part_resp["ETag"],
+                "PartNumber": part_number,
+            }
+            parts.append(part_entry)
+            uploaded_size += len(chunk)
+            part_number += 1
+
+            # Update upload progress in global state
+            await UploadProgress.update(
+                upload_key=file_key, uploaded_bytes=uploaded_size
+            )
+
+            # If the client disconnected mid-upload, abort and evict
+            if await request.is_disconnected():
+                await s3.abort_multipart_upload(
+                    Bucket=settings.RUSTFS_BUCKET_NAME,
+                    Key=file_key,
+                    UploadId=upload_id,
+                )
+                await UploadProgress.cancel(upload_key=file_key)
+                raise HTTPException(status_code=499, detail="Client disconnected")
+
+        if not parts:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Empty file",
+            )
+
+        await s3.complete_multipart_upload(
+            Bucket=settings.RUSTFS_BUCKET_NAME,
+            Key=file_key,
+            UploadId=upload_id,
+            MultipartUpload={"Parts": parts},
+        )
+        await UploadProgress.finish(upload_key=file_key, final_size=uploaded_size)
+    except HTTPException:
+        # Ensure failed uploads are removed from AppState
+        await UploadProgress.cancel(upload_key=file_key)
+        raise
+    except Exception:
+        await s3.abort_multipart_upload(
+            Bucket=settings.RUSTFS_BUCKET_NAME,
+            Key=file_key,
+            UploadId=upload_id,
+        )
+        # Ensure failed uploads are removed from AppState
+        await UploadProgress.cancel(upload_key=file_key)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Upload failed",
+        )
+
+    now = datetime.now(timezone.utc)
+
+    # Persist File record + schedule cleanup in background (non-blocking)
+    persist_file_record.delay(
+        key=file_key,
+        filename=filename,
+        size=uploaded_size,
+        created_at=now.isoformat(),
+        expires_at=room.expires_at.isoformat(),
+        content_type=file.content_type or "application/octet-stream",
+    )
+
+    entry = RoomFileEntry(
+        key=file_key,
+        filename=filename,
+        size=uploaded_size,
+        uploaded_at=now,
+        download_url=f"{settings.ROOT_PATH}/download/{file_key}",
+    )
+
+    # Persist in room state + fan-out event via pub/sub (atomic append)
+    added = await RoomState.add_file(room_id, entry)
+    if not added:
+        # Room vanished mid-upload — clean up the S3 object
+        await s3.delete_object(Bucket=settings.RUSTFS_BUCKET_NAME, Key=file_key)
+        # Remove in-flight upload from global state
+        await UploadProgress.cancel(upload_key=file_key)
+        raise HTTPException(status_code=404, detail="Room expired during upload")
+
+    return entry
+
+
+@router.get("/rooms/{room_id}/files")
+async def list_room_files(room_id: str) -> list[RoomFileEntry]:
+    """Late-joining clients call this to discover all files already in the room."""
+    room = await RoomState.get(room_id)
+    if room is None:
+        raise HTTPException(status_code=404, detail="Room not found or expired")
+    return room.files
+
+
+@router.get("/rooms/{room_id}/files/{file_key:path}/download")
+async def download_room_file(
+    room_id: str,
+    file_key: str,
+    s3: S3Dep,
+) -> StreamingResponse:
+    """Stream a room file from RustFS.  Designed for late or slow clients."""
+    room = await RoomState.get(room_id)
+    if room is None:
+        raise HTTPException(status_code=404, detail="Room not found or expired")
+
+    # Verify the file belongs to this room
+    entry = next((f for f in room.files if f.key == file_key), None)
+    if entry is None:
+        raise HTTPException(status_code=404, detail="File not found in room")
+
+    try:
+        s3_response = await s3.get_object(
+            Bucket=settings.RUSTFS_BUCKET_NAME, Key=file_key
+        )
+    except ClientError as e:
+        code = e.response.get("Error", {}).get("Code")
+        if code == "NoSuchKey":
+            raise HTTPException(status_code=404, detail="File not found in storage")
+        raise HTTPException(status_code=500, detail="Storage error")
+
+    async def _stream():
+        try:
+            async for chunk in s3_response["Body"]:
+                yield chunk
+        finally:
+            s3_response["Body"].close()
+
+    safe_filename = quote(entry.filename)
+    return StreamingResponse(
+        _stream(),
+        media_type=s3_response.get("ContentType", "application/octet-stream"),
+        headers={
+            "Content-Disposition": f"attachment; filename*=UTF-8''{safe_filename}",
+        },
+    )
diff --git a/src/backend/app/routes/http/speedtest.py b/src/backend/app/routes/http/speedtest.py
index 93b84d15..aa6e006a 100644
--- a/src/backend/app/routes/http/speedtest.py
+++ b/src/backend/app/routes/http/speedtest.py
@@ -7,14 +7,14 @@
 from app.schemas.speedtest import UploadPayload
 from app.settings import settings
 
-router = APIRouter()
+router = APIRouter(prefix="/speedtest")
 
 # 1 MB chunk of random data
 CHUNK_SIZE = 1024 * 1024
 RANDOM_BYTES = os.urandom(CHUNK_SIZE)
 
 
-@router.get("/speedtest/download", tags=["Speedtest"])
+@router.get("/download", tags=["Speedtest"])
 async def speedtest_download(
     size: Annotated[
         int,
@@ -59,7 +59,7 @@ async def iter_content() -> AsyncIterator[bytes]:
     )
 
 
-@router.post("/speedtest/upload", tags=["Speedtest"])
+@router.post("/upload", tags=["Speedtest"])
 async def speedtest_upload(request: Request):
     """
     Upload speedtest endpoint.
diff --git a/src/backend/app/routes/http/token.py b/src/backend/app/routes/http/token.py
index 7f24821b..8621e050 100644
--- a/src/backend/app/routes/http/token.py
+++ b/src/backend/app/routes/http/token.py
@@ -2,10 +2,10 @@
 
 from app.deps import CurrentUser
 
-router = APIRouter()
+router = APIRouter(prefix="/token")
 
 
-@router.get("/token/validate", response_model=dict)
+@router.get("/validate", response_model=dict)
 async def validate_token(_: CurrentUser):
     """
     Validates the JWT and returns the corresponding user info.
diff --git a/src/backend/app/routes/http/upload.py b/src/backend/app/routes/http/upload.py
index 8f9004a9..9c42c0ce 100644
--- a/src/backend/app/routes/http/upload.py
+++ b/src/backend/app/routes/http/upload.py
@@ -6,6 +6,7 @@
     APIRouter,
     BackgroundTasks,
     Form,
+    Request,
     HTTPException,
     UploadFile,
     status,
@@ -53,6 +54,7 @@ async def upload_file(
     filename: Annotated[str | None, Form()],
     expire_after_n_download: Annotated[int, Form()],
     expire_after: Annotated[int, Form()],
+    request: Request,
     # Dependency Injection
     s3: S3Dep,
     session: SessionDep,
@@ -141,6 +143,16 @@ async def upload_file(
                 upload_key=str(key), uploaded_bytes=uploaded_size
             )
 
+            # If the client disconnected mid-upload, abort and evict
+            if await request.is_disconnected():
+                await s3.abort_multipart_upload(
+                    Bucket=settings.RUSTFS_BUCKET_NAME,
+                    Key=str(key),
+                    UploadId=upload_id,
+                )
+                await UploadProgress.cancel(upload_key=str(key))
+                raise HTTPException(status_code=499, detail="Client disconnected")
+
         await s3.complete_multipart_upload(
             Bucket=settings.RUSTFS_BUCKET_NAME,
             Key=str(key),
diff --git a/src/backend/app/routes/ws/reverse.py b/src/backend/app/routes/ws/reverse.py
new file mode 100644
index 00000000..15ee0f3f
--- /dev/null
+++ b/src/backend/app/routes/ws/reverse.py
@@ -0,0 +1,207 @@
+import asyncio
+import json
+import logging
+from contextlib import suppress
+
+import aioboto3
+import redis.asyncio as aioredis
+from botocore.exceptions import ClientError
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from app.schemas.reverse import RoomFileEntry, RoomFileEvent
+from app.settings import settings
+from app.states.room import RoomState
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+async def _stream_file_to_ws(ws: WebSocket, entry: RoomFileEntry) -> None:
+    """Fetch a file from RustFS and relay every chunk to *ws*.
+
+    Mirrors the streaming pattern in ``download.py`` — the client receives raw
+    bytes without ever knowing about the backing S3 store.
+    """
+    session = aioboto3.Session()
+    async with session.client(
+        "s3",
+        endpoint_url=settings.RUSTFS_ENDPOINT_URL,
+        aws_access_key_id=settings.RUSTFS_ACCESS_KEY,
+        aws_secret_access_key=settings.RUSTFS_SECRET_ACCESS_KEY,
+    ) as s3:
+        try:
+            s3_response = await s3.get_object(
+                Bucket=settings.RUSTFS_BUCKET_NAME, Key=entry.key
+            )
+        except ClientError:
+            await ws.send_text(
+                json.dumps(
+                    {
+                        "type": "file_error",
+                        "key": entry.key,
+                        "detail": "Not found in storage",
+                    }
+                )
+            )
+            return
+
+        # Header — tells the client which file is coming and how large it is
+        await ws.send_text(
+            json.dumps(
+                {
+                    "type": "file_start",
+                    "key": entry.key,
+                    "filename": entry.filename,
+                    "size": entry.size,
+                }
+            )
+        )
+
+        # Binary chunks — same as ``async for chunk in s3_response["Body"]``
+        try:
+            async for chunk in s3_response["Body"]:
+                await ws.send_bytes(chunk)
+        finally:
+            s3_response["Body"].close()
+
+        # Footer — signals the client that this file is complete
+        await ws.send_text(json.dumps({"type": "file_end", "key": entry.key}))
+
+
+@router.websocket("/ws/reverse/rooms/{room_id}")
+async def room_ws(ws: WebSocket, room_id: str, host_token: str | None = None):
+    # Quick existence check before accepting the connection
+    room = await RoomState.get(room_id)
+    if room is None:
+        await ws.close(code=4004, reason="Room not found or expired")
+        return
+
+    # Determine if this connection is the host
+    is_host = False
+    if host_token is not None:
+        is_host = await RoomState.verify_host(room_id, host_token)
+        if not is_host:
+            await ws.close(code=4003, reason="Invalid host token")
+            return
+
+    await ws.accept()
+
+    # ── subscribe FIRST so no events are lost between snapshot and listen ──
+    sub_client = aioredis.from_url(
+        settings.REDIS_ENDPOINT, encoding="utf-8", decode_responses=True
+    )
+    pubsub = sub_client.pubsub()
+    channel = RoomState.channel_for(room_id)
+    await pubsub.subscribe(channel)
+
+    # ── snapshot (re-read after subscribe to guarantee consistency) ───
+    room = await RoomState.get(room_id)
+    if room is None:
+        await pubsub.unsubscribe(channel)
+        await pubsub.aclose()
+        await sub_client.aclose()
+        await ws.close(code=4004, reason="Room expired")
+        return
+
+    await ws.send_text(
+        json.dumps({"type": "snapshot", "room": room.model_dump(mode="json")})
+    )
+
+    # Queue that serialises all file streams (catch-up + real-time).
+    # Existing files from the snapshot are enqueued first; new events
+    # arriving through pub/sub are appended in order.
+    file_queue: asyncio.Queue[RoomFileEntry | None] = asyncio.Queue()
+    seen_keys: set[str] = set()
+
+    # Enqueue existing files so late clients get them streamed
+    for entry in room.files:
+        seen_keys.add(entry.key)
+        file_queue.put_nowait(entry)
+
+    async def _listen_events() -> None:
+        """Read room events from Redis pub/sub and either queue file
+        streams or forward lightweight notifications.
+
+        Events for files already in the snapshot are deduplicated via
+        ``seen_keys`` so late clients don't receive the same file twice.
+        """
+        try:
+            async for message in pubsub.listen():
+                if message["type"] != "message":
+                    continue
+
+                raw = message["data"]
+                try:
+                    data = json.loads(raw)
+                except Exception:
+                    continue
+
+                # Host destroyed the room — notify client and close
+                if data.get("type") == "room_destroyed":
+                    await ws.send_text(json.dumps({"type": "room_destroyed"}))
+                    file_queue.put_nowait(None)
+                    await ws.close(code=4001, reason="Room destroyed by host")
+                    return
+
+                # Host count changed — forward directly
+                if data.get("type") == "host_count":
+                    await ws.send_text(json.dumps(data))
+                    continue
+
+                try:
+                    event = RoomFileEvent.model_validate(data)
+                except Exception:
+                    logger.exception("Bad event on room channel %s", room_id)
+                    continue
+
+                if event.event == "file_added":
+                    if event.file.key in seen_keys:
+                        # Already queued from the snapshot — skip duplicate
+                        continue
+                    seen_keys.add(event.file.key)
+                    file_queue.put_nowait(event.file)
+                elif event.event == "file_removed":
+                    await ws.send_text(
+                        json.dumps(
+                            {
+                                "type": "file_removed",
+                                "key": event.file.key,
+                                "filename": event.file.filename,
+                            }
+                        )
+                    )
+        except WebSocketDisconnect, asyncio.CancelledError:
+            pass
+
+    # ── streamer — pulls from queue and streams one file at a time ───
+    async def _stream_queued_files() -> None:
+        try:
+            while True:
+                entry = await file_queue.get()
+                if entry is None:
+                    break
+                await _stream_file_to_ws(ws, entry)
+        except WebSocketDisconnect, asyncio.CancelledError:
+            pass
+
+    listen_task = asyncio.create_task(_listen_events())
+    stream_task = asyncio.create_task(_stream_queued_files())
+
+    try:
+        # Keep alive — read (and discard) client pings / messages
+        while True:
+            await ws.receive_text()
+    except WebSocketDisconnect:
+        pass
+    finally:
+        listen_task.cancel()
+        file_queue.put_nowait(None)  # unblock streamer
+        stream_task.cancel()
+        with suppress(asyncio.CancelledError):
+            await listen_task
+        with suppress(asyncio.CancelledError):
+            await stream_task
+        await pubsub.unsubscribe(channel)
+        await pubsub.aclose()
+        await sub_client.aclose()
diff --git a/src/backend/app/schemas/reverse.py b/src/backend/app/schemas/reverse.py
new file mode 100644
index 00000000..a555d108
--- /dev/null
+++ b/src/backend/app/schemas/reverse.py
@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class RoomFileEntry(BaseModel):
+    key: str
+    filename: str
+    size: int
+    uploaded_at: datetime
+    download_url: str
+
+
+class RoomOut(BaseModel):
+    id: str
+    name: str
+    created_at: datetime
+    expires_at: datetime
+    files: list[RoomFileEntry] = []
+    host_count: int = 1
+
+
+class RoomCreateOut(RoomOut):
+    """Returned only once at room creation — includes the host secret."""
+
+    host_token: str
+
+
+class RoomCreate(BaseModel):
+    name: str
+    expire_after: int  # seconds from now
+
+
+class AddHostOut(BaseModel):
+    host_token: str
+
+
+class RoomFileEvent(BaseModel):
+    """Pushed to WebSocket subscribers on file activity."""
+
+    event: str  # "file_added" | "file_removed"
+    file: RoomFileEntry
diff --git a/src/backend/app/settings.py b/src/backend/app/settings.py
index c73f4ef7..e2807397 100644
--- a/src/backend/app/settings.py
+++ b/src/backend/app/settings.py
@@ -74,6 +74,8 @@ def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn | str:
 
     STATE_REDIS_KEY: str = "chithi:global_state"
     STATE_CHANNEL: str = "chithi:state_changed"
+    # Upload cleanup: stale in-flight uploads older than this (seconds) are cleared
+    UPLOAD_STALE_SECONDS: int = 600
 
 
 settings = Settings()  # type: ignore
diff --git a/src/backend/app/states/app.py b/src/backend/app/states/app.py
index 39fe451d..e836e7ef 100644
--- a/src/backend/app/states/app.py
+++ b/src/backend/app/states/app.py
@@ -1,4 +1,5 @@
 from typing import Any
+from datetime import datetime, timezone
 
 import redis.asyncio as redis
 from pydantic import BaseModel
@@ -14,46 +15,68 @@ class UploadProgress(GlobalState, BaseModel):
     filename: str
     uploaded_bytes: int = 0
     done: bool = False
+    last_updated: datetime | None = None
 
     @classmethod
-    async def start(cls, upload_key: str, filename: str) -> AppState:
-        """Register a new in-flight upload."""
+    async def start(cls, upload_key: str, filename: str) -> "AppState":
+        """Register a new in-flight upload and set last_updated."""
         current = await AppState.get()
-        current.active_uploads.append(cls(upload_key=upload_key, filename=filename))
+        now = datetime.now(timezone.utc)
+        current.active_uploads.append(
+            cls(upload_key=upload_key, filename=filename, last_updated=now)
+        )
         await AppState.set(current)
         return current
 
     @classmethod
-    async def update(cls, upload_key: str, uploaded_bytes: int) -> AppState:
-        """Update the byte count for an in-flight upload."""
+    async def update(cls, upload_key: str, uploaded_bytes: int) -> "AppState":
+        """Update the byte count and touch last_updated for an in-flight upload."""
         current = await AppState.get()
+        now = datetime.now(timezone.utc)
         for upload in current.active_uploads:
             if upload.upload_key == upload_key:
+                # Add the delta to total_space_used so partial uploads are accounted
+                delta = uploaded_bytes - (upload.uploaded_bytes or 0)
+                if delta > 0:
+                    current.total_space_used += delta
                 upload.uploaded_bytes = uploaded_bytes
+                upload.last_updated = now
                 break
         await AppState.set(current)
         return current
 
     @classmethod
-    async def finish(cls, upload_key: str, final_size: int) -> AppState:
-        """Mark an upload as done and add its size to total_space_used."""
+    async def finish(cls, upload_key: str, final_size: int) -> "AppState":
+        """Mark an upload as done, touch last_updated, and add its size to total_space_used."""
         current = await AppState.get()
+        now = datetime.now(timezone.utc)
         for upload in current.active_uploads:
             if upload.upload_key == upload_key:
+                # If we tracked partial bytes earlier, only add the remaining delta
+                delta = final_size - (upload.uploaded_bytes or 0)
+                if delta > 0:
+                    current.total_space_used += delta
                 upload.done = True
                 upload.uploaded_bytes = final_size
+                upload.last_updated = now
                 break
-        current.total_space_used += final_size
         await AppState.set(current)
         return current
 
     @classmethod
-    async def cancel(cls, upload_key: str) -> AppState:
-        """Remove a failed/disconnected upload from the active list."""
+    async def cancel(cls, upload_key: str) -> "AppState":
+        """Remove a failed/disconnected upload from the active list without adjusting totals."""
         current = await AppState.get()
-        current.active_uploads = [
-            u for u in current.active_uploads if u.upload_key != upload_key
-        ]
+        # Subtract any tracked uploaded bytes from totals when cancelling
+        remaining = []
+        freed = 0
+        for u in current.active_uploads:
+            if u.upload_key == upload_key:
+                freed += u.uploaded_bytes or 0
+            else:
+                remaining.append(u)
+        current.active_uploads = remaining
+        current.total_space_used = max(0, current.total_space_used - freed)
         await AppState.set(current)
         return current
 
diff --git a/src/backend/app/states/room.py b/src/backend/app/states/room.py
new file mode 100644
index 00000000..e184fe71
--- /dev/null
+++ b/src/backend/app/states/room.py
@@ -0,0 +1,196 @@
+import hashlib
+import json
+import secrets
+import uuid
+from datetime import datetime, timedelta, timezone
+
+from app.schemas.reverse import (
+    AddHostOut,
+    RoomCreateOut,
+    RoomFileEntry,
+    RoomFileEvent,
+    RoomOut,
+)
+from app.states._global import GlobalState
+
+# Lua script: atomically remove an element from a JSON array by matching
+# a field value, and return the removed element (if any).
+_LUA_REMOVE_FILE = """
+local raw = redis.call('JSON.GET', KEYS[1], '$.files')
+if not raw then return nil end
+local outer = cjson.decode(raw)
+local files = outer[1]
+local removed = nil
+local new_files = {}
+for _, f in ipairs(files) do
+    if f['key'] == ARGV[1] then
+        removed = cjson.encode(f)
+    else
+        new_files[#new_files + 1] = f
+    end
+end
+if removed then
+    redis.call('JSON.SET', KEYS[1], '$.files', cjson.encode(new_files))
+end
+return removed
+"""
+
+
+def _room_key(room_id: str) -> str:
+    return f"chithi:room:{room_id}"
+
+
+def _room_channel(room_id: str) -> str:
+    return f"chithi:room:{room_id}:events"
+
+
+class RoomState(GlobalState):
+    """Manage rooms stored in Redis."""
+
+    @classmethod
+    async def create(cls, name: str, expire_after: int) -> RoomCreateOut:
+        room_id = str(uuid.uuid7())
+        now = datetime.now(timezone.utc)
+
+        # Generate a cryptographically random host token; store its
+        # SHA-256 hash in Redis so the plaintext is never persisted.
+        host_token = secrets.token_urlsafe(32)
+        token_hash = hashlib.sha256(host_token.encode()).hexdigest()
+
+        # The Redis document includes host_token_hashes (internal) but
+        # RoomOut (public) never exposes it.
+        payload = {
+            "id": room_id,
+            "name": name,
+            "created_at": now.isoformat(),
+            "expires_at": (now + timedelta(seconds=expire_after)).isoformat(),
+            "files": [],
+            "host_token_hashes": [token_hash],
+        }
+        key = _room_key(room_id)
+        await cls._json_set(key, payload)
+        await cls._client().expire(key, expire_after)
+
+        return RoomCreateOut(
+            id=room_id,
+            name=name,
+            created_at=now,
+            expires_at=now + timedelta(seconds=expire_after),
+            files=[],
+            host_token=host_token,
+        )
+
+    @classmethod
+    async def get(cls, room_id: str) -> RoomOut | None:
+        data = await cls._json_get(_room_key(room_id))
+        if data is None:
+            return None
+        # Compute host_count from internal field before stripping it
+        hashes = data.pop("host_token_hashes", [])
+        data.pop("host_token_hash", None)  # compat with old format
+        data["host_count"] = len(hashes) if isinstance(hashes, list) else 1
+        return RoomOut.model_validate(data)
+
+    @classmethod
+    async def verify_host(cls, room_id: str, host_token: str) -> bool:
+        """Return True if *host_token* matches any stored hash for this room."""
+        data = await cls._json_get(_room_key(room_id))
+        if data is None:
+            return False
+        provided_hash = hashlib.sha256(host_token.encode()).hexdigest()
+        # Support new list format and legacy single-hash format
+        hashes = data.get("host_token_hashes", [])
+        if isinstance(hashes, list):
+            return any(secrets.compare_digest(h, provided_hash) for h in hashes)
+        stored_hash = data.get("host_token_hash", "")
+        return secrets.compare_digest(stored_hash, provided_hash)
+
+    @classmethod
+    async def add_host(cls, room_id: str) -> AddHostOut | None:
+        """Generate a new host token and append its hash to the room."""
+        key = _room_key(room_id)
+        data = await cls._json_get(key)
+        if data is None:
+            return None
+
+        host_token = secrets.token_urlsafe(32)
+        token_hash = hashlib.sha256(host_token.encode()).hexdigest()
+
+        client = cls._client()
+        try:
+            await client.execute_command(
+                "JSON.ARRAPPEND",
+                key,
+                "$.host_token_hashes",
+                json.dumps(token_hash),
+            )
+        except Exception:
+            return None
+
+        # Broadcast host count change so all clients update
+        hashes = data.get("host_token_hashes", [])
+        new_count = (len(hashes) if isinstance(hashes, list) else 1) + 1
+        await cls._publish(
+            _room_channel(room_id),
+            json.dumps({"type": "host_count", "count": new_count}),
+        )
+
+        return AddHostOut(host_token=host_token)
+
+    @classmethod
+    async def delete(cls, room_id: str) -> bool:
+        result = await cls._client().delete(_room_key(room_id))
+        return result > 0
+
+    @classmethod
+    async def add_file(cls, room_id: str, entry: RoomFileEntry) -> bool:
+        """Atomically append a file entry to the room's files array.
+
+        Uses ``JSON.ARRAPPEND`` so concurrent uploads from different FastAPI
+        instances never clobber each other.
+
+        Returns True on success, False if the room no longer exists.
+        """
+        key = _room_key(room_id)
+        client = cls._client()
+        try:
+            await client.execute_command(
+                "JSON.ARRAPPEND",
+                key,
+                "$.files",
+                json.dumps(entry.model_dump(mode="json")),
+            )
+        except Exception:
+            # Key doesn't exist (room expired) or path missing
+            return False
+
+        # Fan-out notification — every subscribed instance picks this up
+        event = RoomFileEvent(event="file_added", file=entry)
+        await cls._publish(_room_channel(room_id), event.model_dump_json())
+        return True
+
+    @classmethod
+    async def remove_file(cls, room_id: str, file_key: str) -> RoomFileEntry | None:
+        """Atomically remove a file by key using a Lua script.
+
+        Returns the removed entry, or None if not found / room expired.
+        """
+        key = _room_key(room_id)
+        client = cls._client()
+        result = await client.eval(_LUA_REMOVE_FILE, 1, key, file_key)  # type: ignore[misc]
+        if result is None:
+            return None
+
+        removed_entry = RoomFileEntry.model_validate_json(result)
+
+        event = RoomFileEvent(event="file_removed", file=removed_entry)
+        await cls._publish(_room_channel(room_id), event.model_dump_json())
+        return removed_entry
+
+    @classmethod
+    def channel_for(cls, room_id: str) -> str:
+        return _room_channel(room_id)
+
+    @classmethod
+    async def publish_event(cls, room_id: str, message: str) -> None:
+        await cls._publish(_room_channel(room_id), message)
diff --git a/src/backend/app/tasks/__init__.py b/src/backend/app/tasks/__init__.py
index 64fbf70c..6598a4cd 100644
--- a/src/backend/app/tasks/__init__.py
+++ b/src/backend/app/tasks/__init__.py
@@ -1 +1,2 @@
 from .clean_file import delete_expired_file as delete_expired_file
+from .persist_file import persist_file_record as persist_file_record
diff --git a/src/backend/app/tasks/persist_file.py b/src/backend/app/tasks/persist_file.py
new file mode 100644
index 00000000..d6a33b2b
--- /dev/null
+++ b/src/backend/app/tasks/persist_file.py
@@ -0,0 +1,44 @@
+from datetime import datetime
+
+from app.celery import celery
+from app.db import AsyncSessionLocal
+from app.models.files import File
+from app.tasks.clean_file import delete_expired_file
+
+
+@celery.task
+async def persist_file_record(
+    key: str,
+    filename: str,
+    size: int,
+    created_at: str,
+    expires_at: str,
+    content_type: str,
+) -> str:
+    """Create a File record in the DB and schedule its cleanup.
+
+    Runs as a Celery background task so the upload HTTP response is not
+    blocked by database I/O.
+    """
+    created = datetime.fromisoformat(created_at)
+    expires = datetime.fromisoformat(expires_at)
+
+    file_record = File(
+        key=key,
+        filename=filename,
+        size=size,
+        created_at=created,
+        expires_at=expires,
+        expire_after_n_download=2**31 - 1,  # effectively unlimited
+        download_count=0,
+    )
+
+    async with AsyncSessionLocal() as session:
+        session.add(file_record)
+        await session.commit()
+        await session.refresh(file_record)
+
+        # Schedule file cleanup at expiry
+        delete_expired_file.apply_async((str(file_record.id),), eta=expires)
+
+    return str(file_record.id)
diff --git a/src/backend/pyproject.toml b/src/backend/pyproject.toml
index 6d809790..4eaf8e75 100644
--- a/src/backend/pyproject.toml
+++ b/src/backend/pyproject.toml
@@ -7,13 +7,13 @@ requires-python = ">=3.14"
 dependencies = [
     # Fastapi
     "fastapi>=0.127.0",
-    "python-multipart>=0.0.21",
     # Faster Loops
     "uvloop>=0.22.1; sys_platform == 'linux'",
     # ASGI server
     "uvicorn>=0.40.0",
     "websockets>=15.0.1",
-    # Password Hashinh
+    "python-multipart>=0.0.21",
+    # Password Hashing
     "pwdlib[argon2]>=0.3.0",
     # Pydantic based settings manager
     "pydantic-settings>=2.12.0",
@@ -32,17 +32,17 @@ dependencies = [
     "celery>=5.6.1", 
     "celery-aio-pool>=0.1.0rc8",
     # Redis for caching
+    "celery-types>=0.24.0",
     "redis[hiredis]>=6.4.0",
     # Mandatory type
     "types-aiobotocore-s3>=2.25.2",
+    "types-aioboto3>=15.5.0",
 ]
 
 [dependency-groups]
 dev = [
-    "celery-types>=0.24.0",
     "fastapi-cli>=0.0.16",
     "ruff>=0.14.10",
-    "types-aioboto3>=15.5.0",
     # Task runner
     "poethepoet>=0.39.0",
 ]
diff --git a/src/backend/scripts/start_celery_beat.sh b/src/backend/scripts/start_celery_beat.sh
new file mode 100644
index 00000000..49db1ebb
--- /dev/null
+++ b/src/backend/scripts/start_celery_beat.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+export CELERY_CUSTOM_WORKER_POOL='celery_aio_pool.pool:AsyncIOPool'
+exec celery -A app.celery beat --loglevel=info
\ No newline at end of file
diff --git a/src/backend/uv.lock b/src/backend/uv.lock
index cb071393..6f7c4953 100644
--- a/src/backend/uv.lock
+++ b/src/backend/uv.lock
@@ -395,6 +395,7 @@ dependencies = [
     { name = "alembic" },
     { name = "celery" },
     { name = "celery-aio-pool" },
+    { name = "celery-types" },
     { name = "fastapi" },
     { name = "pwdlib", extra = ["argon2"] },
     { name = "pydantic-settings" },
@@ -404,6 +405,7 @@ dependencies = [
     { name = "sqlalchemy", extra = ["postgresql-asyncpg"] },
     { name = "sqlmodel" },
     { name = "typer" },
+    { name = "types-aioboto3" },
     { name = "types-aiobotocore-s3" },
     { name = "uvicorn" },
     { name = "uvloop", marker = "sys_platform == 'linux'" },
@@ -412,11 +414,9 @@ dependencies = [
 
 [package.dev-dependencies]
 dev = [
-    { name = "celery-types" },
     { name = "fastapi-cli" },
     { name = "poethepoet" },
     { name = "ruff" },
-    { name = "types-aioboto3" },
 ]
 
 [package.metadata]
@@ -425,6 +425,7 @@ requires-dist = [
     { name = "alembic", specifier = ">=1.17.2" },
     { name = "celery", specifier = ">=5.6.1" },
     { name = "celery-aio-pool", specifier = ">=0.1.0rc8" },
+    { name = "celery-types", specifier = ">=0.24.0" },
     { name = "fastapi", specifier = ">=0.127.0" },
     { name = "pwdlib", extras = ["argon2"], specifier = ">=0.3.0" },
     { name = "pydantic-settings", specifier = ">=2.12.0" },
@@ -434,6 +435,7 @@ requires-dist = [
     { name = "sqlalchemy", extras = ["postgresql-asyncpg"], specifier = ">=2.0.45" },
     { name = "sqlmodel", specifier = ">=0.0.27" },
     { name = "typer", specifier = ">=0.20.1" },
+    { name = "types-aioboto3", specifier = ">=15.5.0" },
     { name = "types-aiobotocore-s3", specifier = ">=2.25.2" },
     { name = "uvicorn", specifier = ">=0.40.0" },
     { name = "uvloop", marker = "sys_platform == 'linux'", specifier = ">=0.22.1" },
@@ -442,11 +444,9 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "celery-types", specifier = ">=0.24.0" },
     { name = "fastapi-cli", specifier = ">=0.0.16" },
     { name = "poethepoet", specifier = ">=0.39.0" },
     { name = "ruff", specifier = ">=0.14.10" },
-    { name = "types-aioboto3", specifier = ">=15.5.0" },
 ]
 
 [[package]]
diff --git a/src/frontend/src/lib/components/ui/sonner/sonner.svelte b/src/frontend/src/lib/components/ui/sonner/sonner.svelte
index f75e34c4..742b14d7 100644
--- a/src/frontend/src/lib/components/ui/sonner/sonner.svelte
+++ b/src/frontend/src/lib/components/ui/sonner/sonner.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
 	import CircleCheckIcon from '@lucide/svelte/icons/circle-check';
 	import InfoIcon from '@lucide/svelte/icons/info';
-	import Loader2Icon from '@lucide/svelte/icons/loader-2';
+	import LoaderCircle from '@lucide/svelte/icons/loader-circle';
 	import OctagonXIcon from '@lucide/svelte/icons/octagon-x';
 	import TriangleAlertIcon from '@lucide/svelte/icons/triangle-alert';
 
@@ -17,7 +17,7 @@
 	style="--normal-bg: var(--color-popover); --normal-text: var(--color-popover-foreground); --normal-border: var(--color-border);"
 	{...restProps}
 	>{#snippet loadingIcon()}
-		<Loader2Icon class="size-4 animate-spin" />
+		<LoaderCircle class="size-4 animate-spin" />
 	{/snippet}
 	{#snippet successIcon()}
 		<CircleCheckIcon class="size-4" />
diff --git a/src/frontend/src/lib/consts/backend.ts b/src/frontend/src/lib/consts/backend.ts
index 10d41998..a41eb9a9 100644
--- a/src/frontend/src/lib/consts/backend.ts
+++ b/src/frontend/src/lib/consts/backend.ts
@@ -13,3 +13,6 @@ export const TOKEN_VALIDATE_URL = `${BACKEND_API}/token/validate`;
 export const ADMIN_CONFIG_URL = `${BACKEND_API}/admin/config`;
 export const ADMIN_USER_UPDATE_URL = `${BACKEND_API}/admin/user`;
 export const ADMIN_FILES_URL = `${BACKEND_API}/admin/files`;
+
+export const REVERSE_ROOMS_URL = `${BACKEND_API}/reverse/rooms`;
+export const REVERSE_WS_URL = BACKEND_API.replace(/^http/, 'ws') + '/ws/reverse/rooms';
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/+page.svelte b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/+page.svelte
new file mode 100644
index 00000000..2c63b48c
--- /dev/null
+++ b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/+page.svelte
@@ -0,0 +1,119 @@
+<script lang="ts">
+	import { goto } from '$app/navigation';
+	import { toast } from 'svelte-sonner';
+	import {
+		Card,
+		CardContent,
+		CardDescription,
+		CardFooter,
+		CardHeader,
+		CardTitle
+	} from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { Input } from '$lib/components/ui/input';
+	import { Label } from '$lib/components/ui/label';
+	import { Upload, Gauge, ArrowLeftRight, PlugZap } from 'lucide-svelte';
+
+	let showReconnect = $state(false);
+	let reconnectUrl = $state('');
+
+	function handleReconnect() {
+		const raw = reconnectUrl.trim();
+		if (!raw) {
+			toast.error('Please paste your host link');
+			return;
+		}
+
+		try {
+			const url = new URL(raw, window.location.origin);
+			const pathMatch = url.pathname.match(/\/reverse\/([^/]+)/);
+			if (!pathMatch) {
+				toast.error('Invalid link — expected a /reverse/<room_id> URL');
+				return;
+			}
+			const roomId = pathMatch[1];
+			const hash = url.hash; // includes the '#'
+			goto(`/reverse/${roomId}${hash}`);
+		} catch {
+			toast.error('Invalid URL');
+		}
+	}
+</script>
+
+<div class="flex min-h-[70vh] items-center justify-center p-4">
+	<div class="w-full max-w-2xl space-y-8">
+		<div class="space-y-2 text-center">
+			<h1 class="text-4xl font-bold tracking-tight">Chithi</h1>
+			<p class="text-lg text-muted-foreground">
+				Encrypt and send files with a link that automatically expires. What would you like to do?
+			</p>
+		</div>
+
+		<div class="grid gap-4 sm:grid-cols-2">
+			<a href="/upload/" class="no-underline">
+				<Card class="h-full cursor-pointer transition-shadow hover:shadow-md">
+					<CardHeader class="flex flex-col items-center text-center">
+						<Upload class="mb-2 h-8 w-8 text-primary" />
+						<CardTitle>Upload</CardTitle>
+						<CardDescription>
+							Send a file securely with an expiring, password-protected link.
+						</CardDescription>
+					</CardHeader>
+				</Card>
+			</a>
+
+			<a href="/reverse/" class="no-underline">
+				<Card class="h-full cursor-pointer transition-shadow hover:shadow-md">
+					<CardHeader class="flex flex-col items-center text-center">
+						<ArrowLeftRight class="mb-2 h-8 w-8 text-primary" />
+						<CardTitle>Reverse Share</CardTitle>
+						<CardDescription>
+							Create or join a room for real-time peer file transfer.
+						</CardDescription>
+					</CardHeader>
+				</Card>
+			</a>
+
+			<a href="/speedtest/" class="no-underline sm:col-span-2">
+				<Card class="h-full cursor-pointer transition-shadow hover:shadow-md">
+					<CardHeader class="flex flex-col items-center text-center">
+						<Gauge class="mb-2 h-8 w-8 text-primary" />
+						<CardTitle>Speed Test</CardTitle>
+						<CardDescription>
+							Measure your upload and download speeds to this server.
+						</CardDescription>
+					</CardHeader>
+				</Card>
+			</a>
+		</div>
+
+		{#if showReconnect}
+			<Card>
+				<CardHeader>
+					<CardTitle class="flex items-center gap-2">
+						<PlugZap class="h-5 w-5" />
+						Reconnect to Room
+					</CardTitle>
+					<CardDescription>
+						Paste the host link you received when creating the room (the URL with the # token).
+					</CardDescription>
+				</CardHeader>
+				<CardContent>
+					<div class="space-y-2">
+						<Label for="reconnect-url">Host Link</Label>
+						<Input
+							id="reconnect-url"
+							placeholder="https://…/reverse/room-id#host-token"
+							bind:value={reconnectUrl}
+							onkeydown={(e) => e.key === 'Enter' && handleReconnect()}
+						/>
+					</div>
+				</CardContent>
+				<CardFooter class="flex gap-2">
+					<Button variant="outline" onclick={() => (showReconnect = false)}>Cancel</Button>
+					<Button onclick={handleReconnect} class="flex-1">Reconnect</Button>
+				</CardFooter>
+			</Card>
+		{/if}
+	</div>
+</div>
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/+page.svelte b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/+page.svelte
new file mode 100644
index 00000000..446f99b7
--- /dev/null
+++ b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/+page.svelte
@@ -0,0 +1,187 @@
+<script lang="ts">
+	import { goto } from '$app/navigation';
+	import { page } from '$app/state';
+	import { toast } from 'svelte-sonner';
+	import {
+		Card,
+		CardContent,
+		CardDescription,
+		CardFooter,
+		CardHeader,
+		CardTitle
+	} from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { Input } from '$lib/components/ui/input';
+	import { Label } from '$lib/components/ui/label';
+	import { Upload, Download, ArrowLeft, LoaderCircle } from 'lucide-svelte';
+	import { REVERSE_ROOMS_URL } from '#consts/backend';
+
+	type LandingView = 'main' | 'create' | 'join';
+	let landingView = $state<LandingView>('main');
+
+	let roomName = $state('');
+	let expireAfter = $state(3600);
+	let joinId = $state('');
+	let isCreating = $state(false);
+
+	$effect(() => {
+		const prefilledId = page.url.searchParams.get('join');
+		if (prefilledId) {
+			joinId = prefilledId;
+			landingView = 'join';
+		}
+	});
+
+	async function createRoom() {
+		if (!roomName.trim()) {
+			toast.error('Please enter a room name');
+			return;
+		}
+		isCreating = true;
+		try {
+			const res = await fetch(REVERSE_ROOMS_URL, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ name: roomName.trim(), expire_after: expireAfter }),
+				credentials: 'include'
+			});
+			if (!res.ok) {
+				const err = await res.json().catch(() => ({}));
+				throw new Error((err as { detail?: string }).detail ?? `HTTP ${res.status}`);
+			}
+			const data = (await res.json()) as { id: string; host_token: string };
+			goto(`/reverse/${data.id}#host=${data.host_token}`);
+		} catch (e: unknown) {
+			toast.error(`Failed to create room: ${e instanceof Error ? e.message : String(e)}`);
+		} finally {
+			isCreating = false;
+		}
+	}
+
+	function goJoin() {
+		const id = joinId.trim();
+		if (!id) {
+			toast.error('Please enter a room ID');
+			return;
+		}
+		goto(`/reverse/${id}`);
+	}
+</script>
+
+<div class="flex min-h-[70vh] items-center justify-center p-4">
+	<div class="w-full max-w-2xl space-y-6">
+		<div class="space-y-1 text-center">
+			<h1 class="text-3xl font-bold tracking-tight">Reverse File Share</h1>
+			<p class="text-muted-foreground">
+				Host a room to push files to everyone — clients receive them in real time or download via a
+				permanent link.
+			</p>
+		</div>
+
+		{#if landingView === 'main'}
+			<div class="grid gap-4 sm:grid-cols-2">
+				<Card
+					class="cursor-pointer transition-shadow hover:shadow-md"
+					onclick={() => (landingView = 'create')}
+				>
+					<CardHeader>
+						<CardTitle class="flex items-center gap-2">
+							<Upload class="h-5 w-5" />
+							Create a Room
+						</CardTitle>
+						<CardDescription>
+							Host a room and share files. Guests receive them in real time via WebSocket.
+						</CardDescription>
+					</CardHeader>
+				</Card>
+
+				<Card
+					class="cursor-pointer transition-shadow hover:shadow-md"
+					onclick={() => (landingView = 'join')}
+				>
+					<CardHeader>
+						<CardTitle class="flex items-center gap-2">
+							<Download class="h-5 w-5" />
+							Join a Room
+						</CardTitle>
+						<CardDescription>
+							Enter a room ID or follow a shared link to receive files from the host.
+						</CardDescription>
+					</CardHeader>
+				</Card>
+			</div>
+		{:else if landingView === 'create'}
+			<Card>
+				<CardHeader>
+					<CardTitle class="flex items-center gap-2">
+						<Upload class="h-5 w-5" />
+						Create a Room
+					</CardTitle>
+				</CardHeader>
+				<CardContent class="space-y-4">
+					<div class="space-y-2">
+						<Label for="room-name">Room Name</Label>
+						<Input
+							id="room-name"
+							placeholder="My share session"
+							bind:value={roomName}
+							onkeydown={(e) => e.key === 'Enter' && createRoom()}
+						/>
+					</div>
+					<div class="space-y-2">
+						<Label for="expire">Expires after (seconds)</Label>
+						<Input id="expire" type="number" min="60" max="86400" bind:value={expireAfter} />
+						<p class="text-xs text-muted-foreground">
+							{#if expireAfter >= 3600}
+								{(expireAfter / 3600).toFixed(1)} hour(s)
+							{:else}
+								{Math.round(expireAfter / 60)} minute(s)
+							{/if}
+						</p>
+					</div>
+				</CardContent>
+				<CardFooter class="flex gap-2">
+					<Button variant="outline" onclick={() => (landingView = 'main')}>
+						<ArrowLeft class="mr-1 h-4 w-4" />
+						Back
+					</Button>
+					<Button onclick={createRoom} disabled={isCreating} class="flex-1">
+						{#if isCreating}
+							<LoaderCircle class="mr-2 h-4 w-4 animate-spin" />
+							Creating…
+						{:else}
+							Create Room
+						{/if}
+					</Button>
+				</CardFooter>
+			</Card>
+		{:else if landingView === 'join'}
+			<Card>
+				<CardHeader>
+					<CardTitle class="flex items-center gap-2">
+						<Download class="h-5 w-5" />
+						Join a Room
+					</CardTitle>
+				</CardHeader>
+				<CardContent class="space-y-4">
+					<div class="space-y-2">
+						<Label for="room-id">Room ID</Label>
+						<Input
+							id="room-id"
+							placeholder="Paste room ID here"
+							bind:value={joinId}
+							onkeydown={(e) => e.key === 'Enter' && goJoin()}
+						/>
+					</div>
+				</CardContent>
+				<CardFooter class="flex gap-2">
+					<Button variant="outline" onclick={() => (landingView = 'main')}>
+						<ArrowLeft class="mr-1 h-4 w-4" />
+						Back
+					</Button>
+					<Button onclick={goJoin} class="flex-1">Join Room</Button>
+				</CardFooter>
+			</Card>
+		{/if}
+	</div>
+</div>
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/[room_id]/+page.svelte b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/[room_id]/+page.svelte
new file mode 100644
index 00000000..98c9b6c9
--- /dev/null
+++ b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/[room_id]/+page.svelte
@@ -0,0 +1,826 @@
+<script lang="ts">
+	import { onDestroy, onMount } from 'svelte';
+	import { goto } from '$app/navigation';
+	import { page } from '$app/state';
+	import { cubicOut } from 'svelte/easing';
+	import { Tween } from 'svelte/motion';
+	import { toast } from 'svelte-sonner';
+	import {
+		Card,
+		CardContent,
+		CardDescription,
+		CardFooter,
+		CardHeader,
+		CardTitle
+	} from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { Progress } from '$lib/components/ui/progress';
+	import { Badge } from '$lib/components/ui/badge';
+	import { Separator } from '$lib/components/ui/separator';
+	import * as Tooltip from '$lib/components/ui/tooltip/index';
+	import {
+		Upload,
+		Download,
+		Copy,
+		Check,
+		Link,
+		Plus,
+		X,
+		Users,
+		FileIcon,
+		LoaderCircle,
+		ArrowLeft,
+		Wifi,
+		WifiOff,
+		UserPlus
+	} from 'lucide-svelte';
+	import { formatFileSize } from '#functions/bytes';
+	import { REVERSE_ROOMS_URL, REVERSE_WS_URL } from '#consts/backend';
+
+	interface RoomFileEntry {
+		key: string;
+		filename: string;
+		size: number;
+		uploaded_at: string;
+		download_url: string;
+	}
+
+	interface RoomOut {
+		id: string;
+		name: string;
+		expires_at: string;
+		files: RoomFileEntry[];
+		host_count: number;
+	}
+
+	type ReceiveState =
+		| { type: 'idle' }
+		| {
+				type: 'streaming';
+				key: string;
+				filename: string;
+				size: number;
+				received: number;
+				chunks: ArrayBuffer[];
+		  };
+
+	interface UploadEntry {
+		file: File;
+		progress: Tween<number>;
+		status: 'pending' | 'uploading' | 'done' | 'error';
+		entry?: RoomFileEntry;
+	}
+
+	interface DownloadedFile {
+		key: string;
+		filename: string;
+		size: number;
+		objectUrl?: string;
+	}
+
+	let room_id = $derived(page.params.room_id);
+
+	function fileDownloadUrl(fileKey: string): string {
+		return `${REVERSE_ROOMS_URL}/${room_id}/files/${fileKey}/download`;
+	}
+
+	// Host token is passed via URL fragment hash so it never leaks in share links.
+	// Format: #<token>
+	let hostToken = $state<string | null>(null);
+	let isHost = $derived(hostToken !== null);
+
+	$effect(() => {
+		if (typeof window === 'undefined') return;
+		const hash = window.location.hash.slice(1);
+		if (hash) {
+			hostToken = hash;
+		}
+	});
+
+	type LoadStatus = 'loading' | 'not_found' | 'error' | 'loaded';
+	let loadStatus = $state<LoadStatus>('loading');
+	let room = $state<RoomOut | null>(null);
+	let roomFiles = $state<RoomFileEntry[]>([]);
+	let hostCount = $state(1);
+
+	// Host upload
+	let pendingFiles = $state<File[]>([]);
+	let fileInput = $state<HTMLInputElement>();
+	let uploads = $state<UploadEntry[]>([]);
+	let isUploading = $state(false);
+	let overallProgress = $state(new Tween(0, { duration: 400, easing: cubicOut }));
+
+	// Client streaming
+	let receiveState = $state<ReceiveState>({ type: 'idle' });
+	let downloadedFiles = $state<DownloadedFile[]>([]);
+
+	// WebSocket
+	let ws = $state<WebSocket | null>(null);
+	let wsConnected = $state(false);
+
+	// Copy state
+	let copiedShareLink = $state(false);
+	let copiedFileKeys = $state(new Set<string>());
+	let copiedInviteLink = $state(false);
+	let isInviting = $state(false);
+
+	let shareUrl = $derived(
+		typeof window !== 'undefined'
+			? `${window.location.origin}/reverse/${room_id}`
+			: `/reverse/${room_id}`
+	);
+
+	let totalUploadSize = $derived(pendingFiles.reduce((s, f) => s + f.size, 0));
+	let completedUploads = $derived(uploads.filter((u) => u.status === 'done').length);
+	let totalUploads = $derived(uploads.length);
+
+	let streamProgress = $derived(
+		receiveState.type === 'streaming' && receiveState.size > 0
+			? (receiveState.received / receiveState.size) * 100
+			: 0
+	);
+
+	async function loadRoom() {
+		loadStatus = 'loading';
+		try {
+			const res = await fetch(`${REVERSE_ROOMS_URL}/${room_id}`, { credentials: 'include' });
+			if (res.status === 404) {
+				loadStatus = 'not_found';
+				return;
+			}
+			if (!res.ok) {
+				loadStatus = 'error';
+				return;
+			}
+			const data: RoomOut = await res.json();
+			room = data;
+			roomFiles = [...data.files];
+			hostCount = data.host_count ?? 1;
+			loadStatus = 'loaded';
+			connectWebSocket();
+		} catch {
+			loadStatus = 'error';
+		}
+	}
+
+	function connectWebSocket() {
+		if (ws) ws.close();
+		let wsUrl = `${REVERSE_WS_URL}/${room_id}`;
+		if (hostToken) wsUrl += `?host_token=${encodeURIComponent(hostToken)}`;
+		const socket = new WebSocket(wsUrl);
+		ws = socket;
+		wsConnected = false;
+
+		socket.onopen = () => {
+			wsConnected = true;
+		};
+		socket.onclose = () => {
+			wsConnected = false;
+			ws = null;
+		};
+		socket.onerror = () => {
+			wsConnected = false;
+			toast.error('WebSocket connection error');
+		};
+
+		socket.onmessage = (ev) => {
+			if (ev.data instanceof ArrayBuffer || ev.data instanceof Blob) {
+				if (!isHost) handleBinaryChunk(ev.data);
+				return;
+			}
+
+			let msg: Record<string, unknown>;
+			try {
+				msg = JSON.parse(ev.data as string);
+			} catch {
+				return;
+			}
+
+			const type = msg.type as string;
+
+			if (type === 'snapshot') {
+				const r = msg.room as RoomOut;
+				room = r;
+				roomFiles = [...r.files];
+				hostCount = r.host_count ?? 1;
+			} else if (type === 'host_count') {
+				hostCount = msg.count as number;
+			} else if (type === 'file_start' && !isHost) {
+				receiveState = {
+					type: 'streaming',
+					key: msg.key as string,
+					filename: msg.filename as string,
+					size: msg.size as number,
+					received: 0,
+					chunks: []
+				};
+			} else if (type === 'file_end' && !isHost && receiveState.type === 'streaming') {
+				const { key, filename, size, chunks } = receiveState;
+				const blob = new Blob(chunks);
+				const objectUrl = URL.createObjectURL(blob);
+				downloadedFiles = [...downloadedFiles, { key, filename, size, objectUrl }];
+				receiveState = { type: 'idle' };
+				toast.success(`Received: ${filename}`);
+			} else if (type === 'file_error') {
+				receiveState = { type: 'idle' };
+				toast.error(`File error: ${msg.detail}`);
+			} else if (type === 'file_removed') {
+				const removedKey = msg.key as string;
+				roomFiles = roomFiles.filter((f) => f.key !== removedKey);
+				downloadedFiles = downloadedFiles.filter((f) => f.key !== removedKey);
+			} else if (type === 'room_destroyed') {
+				toast.info('The host has closed the room.');
+				cleanup();
+				goto('/reverse');
+				return;
+			}
+		};
+	}
+
+	async function handleBinaryChunk(data: ArrayBuffer | Blob) {
+		const buf = data instanceof Blob ? await data.arrayBuffer() : data;
+		if (receiveState.type !== 'streaming') return;
+		const chunk = new Uint8Array(buf);
+		receiveState.chunks.push(buf);
+		receiveState.received += chunk.byteLength;
+	}
+
+	function addFiles(selected: FileList | null) {
+		if (!selected) return;
+		pendingFiles = [...pendingFiles, ...Array.from(selected)];
+	}
+
+	function removePendingFile(index: number) {
+		pendingFiles = pendingFiles.filter((_, i) => i !== index);
+	}
+
+	async function uploadAll() {
+		if (!room || pendingFiles.length === 0) return;
+		isUploading = true;
+		overallProgress = new Tween(0, { duration: 400, easing: cubicOut });
+
+		const batch: UploadEntry[] = pendingFiles.map((f) => ({
+			file: f,
+			progress: new Tween(0, { duration: 300, easing: cubicOut }),
+			status: 'pending' as const
+		}));
+		uploads = [...uploads, ...batch];
+		pendingFiles = [];
+
+		for (const entry of batch) {
+			entry.status = 'uploading';
+			uploads = uploads;
+
+			try {
+				const fileEntry = await uploadFileXhr(entry.file, (pct) => {
+					entry.progress.target = pct;
+					const done = uploads.filter((u) => u.status === 'done').length;
+					overallProgress.target = ((done + pct / 100) / batch.length) * 100;
+					uploads = uploads;
+				});
+				entry.status = 'done';
+				entry.entry = fileEntry;
+				if (!roomFiles.find((f) => f.key === fileEntry.key)) {
+					roomFiles = [...roomFiles, fileEntry];
+				}
+			} catch (e: unknown) {
+				entry.status = 'error';
+				toast.error(
+					`Upload failed for ${entry.file.name}: ${e instanceof Error ? e.message : String(e)}`
+				);
+			}
+			uploads = uploads;
+		}
+
+		overallProgress.target = 100;
+		isUploading = false;
+	}
+
+	function uploadFileXhr(file: File, onProgress: (pct: number) => void): Promise<RoomFileEntry> {
+		return new Promise((resolve, reject) => {
+			const fd = new FormData();
+			fd.append('file', file, file.name);
+
+			const xhr = new XMLHttpRequest();
+			xhr.open('POST', `${REVERSE_ROOMS_URL}/${room_id}/upload`);
+			xhr.withCredentials = true;
+			if (hostToken) xhr.setRequestHeader('X-Host-Token', hostToken);
+
+			xhr.upload.onprogress = (e) => {
+				if (e.lengthComputable) onProgress((e.loaded / e.total) * 100);
+			};
+
+			xhr.onload = () => {
+				if (xhr.status >= 200 && xhr.status < 300) {
+					try {
+						resolve(JSON.parse(xhr.responseText) as RoomFileEntry);
+					} catch {
+						reject(new Error('Invalid server response'));
+					}
+				} else {
+					let detail = `HTTP ${xhr.status}`;
+					try {
+						detail = (JSON.parse(xhr.responseText) as { detail: string }).detail ?? detail;
+					} catch {
+						/* ignore */
+					}
+					reject(new Error(detail));
+				}
+			};
+
+			xhr.onerror = () => reject(new Error('Network error'));
+			xhr.send(fd);
+		});
+	}
+
+	async function copyShareLink() {
+		await navigator.clipboard.writeText(shareUrl);
+		copiedShareLink = true;
+		setTimeout(() => (copiedShareLink = false), 2000);
+	}
+
+	async function inviteHost() {
+		if (!hostToken) return;
+		isInviting = true;
+		try {
+			const res = await fetch(`${REVERSE_ROOMS_URL}/${room_id}/hosts`, {
+				method: 'POST',
+				credentials: 'include',
+				headers: { 'X-Host-Token': hostToken }
+			});
+			if (!res.ok) {
+				const err = await res.json().catch(() => ({}));
+				throw new Error((err as { detail?: string }).detail ?? `HTTP ${res.status}`);
+			}
+			const data = (await res.json()) as { host_token: string };
+			const inviteUrl = `${window.location.origin}/reverse/${room_id}#${data.host_token}`;
+			await navigator.clipboard.writeText(inviteUrl);
+			copiedInviteLink = true;
+			toast.success('Host invite link copied to clipboard');
+			setTimeout(() => (copiedInviteLink = false), 3000);
+		} catch (e: unknown) {
+			toast.error(`Failed to create invite: ${e instanceof Error ? e.message : String(e)}`);
+		} finally {
+			isInviting = false;
+		}
+	}
+
+	async function copyDownloadLink(key: string, url: string) {
+		await navigator.clipboard.writeText(url);
+		copiedFileKeys = new Set([...copiedFileKeys, key]);
+		setTimeout(() => {
+			copiedFileKeys = new Set([...copiedFileKeys].filter((k) => k !== key));
+		}, 2000);
+	}
+
+	function leaveRoom() {
+		cleanup();
+		goto('/reverse');
+	}
+
+	function cleanup() {
+		if (ws) ws.close();
+		downloadedFiles.forEach((f) => {
+			if (f.objectUrl) URL.revokeObjectURL(f.objectUrl);
+		});
+	}
+
+	onMount(loadRoom);
+	onDestroy(cleanup);
+</script>
+
+<!-- ── Loading ── -->
+{#if loadStatus === 'loading'}
+	<div class="flex min-h-[70vh] items-center justify-center">
+		<div class="flex items-center gap-3 text-muted-foreground">
+			<LoaderCircle class="h-6 w-6 animate-spin" />
+			<span>Loading room…</span>
+		</div>
+	</div>
+
+	<!-- ── Not found ── -->
+{:else if loadStatus === 'not_found'}
+	<div class="flex min-h-[70vh] items-center justify-center p-4">
+		<div class="space-y-4 text-center">
+			<h2 class="text-2xl font-bold">Room Not Found</h2>
+			<p class="text-muted-foreground">This room doesn't exist or has expired.</p>
+			<Button onclick={() => goto('/reverse')}>
+				<ArrowLeft class="mr-2 h-4 w-4" />
+				Back to Reverse Share
+			</Button>
+		</div>
+	</div>
+
+	<!-- ── Error ── -->
+{:else if loadStatus === 'error'}
+	<div class="flex min-h-[70vh] items-center justify-center p-4">
+		<div class="space-y-4 text-center">
+			<h2 class="text-2xl font-bold">Something went wrong</h2>
+			<p class="text-muted-foreground">Failed to load the room. Please try again.</p>
+			<div class="flex justify-center gap-2">
+				<Button variant="outline" onclick={() => goto('/reverse')}>
+					<ArrowLeft class="mr-2 h-4 w-4" />
+					Go Back
+				</Button>
+				<Button onclick={loadRoom}>Retry</Button>
+			</div>
+		</div>
+	</div>
+
+	<!-- ── Room ── -->
+{:else if loadStatus === 'loaded' && room}
+	<div class="mx-auto max-w-3xl space-y-6 p-4">
+		<!-- Header -->
+		<div class="flex flex-wrap items-center justify-between gap-3">
+			<div class="space-y-1">
+				<div class="flex items-center gap-2">
+					<h1 class="text-2xl font-bold">{room.name}</h1>
+					<Badge variant={isHost ? 'default' : 'secondary'}>
+						{isHost ? 'Host' : 'Guest'}
+					</Badge>
+					<Tooltip.Provider>
+						<Tooltip.Root>
+							<Tooltip.Trigger>
+								<Badge variant="outline" class="gap-1">
+									<Users class="h-3 w-3" />
+									{hostCount}
+									{hostCount === 1 ? 'host' : 'hosts'}
+								</Badge>
+							</Tooltip.Trigger>
+							<Tooltip.Content>
+								{hostCount} host{hostCount === 1 ? '' : 's'} can upload to this room
+							</Tooltip.Content>
+						</Tooltip.Root>
+					</Tooltip.Provider>
+					<Tooltip.Provider>
+						<Tooltip.Root>
+							<Tooltip.Trigger>
+								{#if wsConnected}
+									<Wifi class="h-4 w-4 text-muted-foreground" />
+								{:else}
+									<WifiOff class="h-4 w-4 text-destructive" />
+								{/if}
+							</Tooltip.Trigger>
+							<Tooltip.Content>
+								{wsConnected ? 'WebSocket connected' : 'Disconnected'}
+							</Tooltip.Content>
+						</Tooltip.Root>
+					</Tooltip.Provider>
+				</div>
+				<p class="text-sm text-muted-foreground">
+					Expires: {new Date(room.expires_at).toLocaleString()}
+				</p>
+			</div>
+
+			<div class="flex items-center gap-2">
+				<Tooltip.Provider>
+					<Tooltip.Root>
+						<Tooltip.Trigger>
+							<Button variant="outline" size="sm" onclick={copyShareLink}>
+								{#if copiedShareLink}
+									<Check class="mr-1 h-4 w-4 text-green-500" />
+									Copied!
+								{:else}
+									<Link class="mr-1 h-4 w-4" />
+									Share Link
+								{/if}
+							</Button>
+						</Tooltip.Trigger>
+						<Tooltip.Content>{shareUrl}</Tooltip.Content>
+					</Tooltip.Root>
+				</Tooltip.Provider>
+
+				{#if isHost}
+					<Tooltip.Provider>
+						<Tooltip.Root>
+							<Tooltip.Trigger>
+								<Button variant="outline" size="sm" onclick={inviteHost} disabled={isInviting}>
+									{#if copiedInviteLink}
+										<Check class="mr-1 h-4 w-4 text-green-500" />
+										Copied!
+									{:else if isInviting}
+										<LoaderCircle class="mr-1 h-4 w-4 animate-spin" />
+										Inviting…
+									{:else}
+										<UserPlus class="mr-1 h-4 w-4" />
+										Invite Host
+									{/if}
+								</Button>
+							</Tooltip.Trigger>
+							<Tooltip.Content>Generate and copy a host invite link</Tooltip.Content>
+						</Tooltip.Root>
+					</Tooltip.Provider>
+				{/if}
+
+				<Button variant="outline" size="sm" onclick={leaveRoom}>
+					<ArrowLeft class="mr-1 h-4 w-4" />
+					Leave
+				</Button>
+			</div>
+		</div>
+
+		<Separator />
+
+		<!-- ── Host: file picker + upload ── -->
+		{#if isHost}
+			<Card>
+				<CardHeader>
+					<CardTitle class="flex items-center gap-2 text-base">
+						<Upload class="h-4 w-4" />
+						Upload Files
+					</CardTitle>
+					<CardDescription>
+						Files you upload are pushed to all connected clients via WebSocket. A permanent download
+						link is also generated for each file.
+					</CardDescription>
+				</CardHeader>
+				<CardContent class="space-y-4">
+					<!-- Drop zone -->
+					<div
+						class="flex cursor-pointer flex-col items-center justify-center rounded-lg border-2 border-dashed border-muted-foreground/30 px-6 py-10 transition-colors hover:border-primary/60"
+						onclick={() => fileInput?.click()}
+						onkeydown={(e) => e.key === 'Enter' && fileInput?.click()}
+						role="button"
+						tabindex="0"
+						ondragover={(e) => e.preventDefault()}
+						ondrop={(e) => {
+							e.preventDefault();
+							addFiles(e.dataTransfer?.files ?? null);
+						}}
+					>
+						<Plus class="mb-2 h-8 w-8 text-muted-foreground" />
+						<p class="text-sm text-muted-foreground">Click or drop files here</p>
+						<input
+							bind:this={fileInput}
+							type="file"
+							multiple
+							class="hidden"
+							onchange={(e) => addFiles((e.currentTarget as HTMLInputElement).files)}
+						/>
+					</div>
+
+					<!-- Pending queue -->
+					{#if pendingFiles.length > 0}
+						<div class="space-y-2">
+							<p class="text-xs font-medium tracking-wide text-muted-foreground uppercase">
+								Queued — {formatFileSize(totalUploadSize)}
+							</p>
+							{#each pendingFiles as file, i}
+								<div class="flex items-center gap-3 rounded-md border px-3 py-2">
+									<FileIcon class="h-4 w-4 shrink-0 text-muted-foreground" />
+									<span class="min-w-0 flex-1 truncate text-sm">{file.name}</span>
+									<span class="shrink-0 text-xs text-muted-foreground"
+										>{formatFileSize(file.size)}</span
+									>
+									<button
+										class="shrink-0 text-muted-foreground hover:text-destructive"
+										onclick={() => removePendingFile(i)}
+										aria-label="Remove"
+									>
+										<X class="h-4 w-4" />
+									</button>
+								</div>
+							{/each}
+						</div>
+					{/if}
+
+					<!-- Overall progress -->
+					{#if isUploading || (uploads.length > 0 && completedUploads < totalUploads)}
+						<div class="space-y-1">
+							<div class="flex justify-between text-xs">
+								<span class="text-muted-foreground"
+									>Overall — {completedUploads}/{totalUploads} files</span
+								>
+								<span class="text-muted-foreground">{overallProgress.current.toFixed(0)}%</span>
+							</div>
+							<Progress value={overallProgress.current} max={100} />
+						</div>
+					{/if}
+
+					<!-- Per-file rows -->
+					{#if uploads.length > 0}
+						<div class="space-y-2">
+							{#each uploads as u}
+								<div class="space-y-1 rounded-md border px-3 py-2">
+									<div class="flex items-center gap-2">
+										<FileIcon class="h-4 w-4 shrink-0 text-muted-foreground" />
+										<span class="min-w-0 flex-1 truncate text-sm">{u.file.name}</span>
+										<span class="shrink-0 text-xs text-muted-foreground"
+											>{formatFileSize(u.file.size)}</span
+										>
+										{#if u.status === 'done'}
+											<Check class="h-4 w-4 shrink-0 text-green-500" />
+										{:else if u.status === 'error'}
+											<X class="h-4 w-4 shrink-0 text-destructive" />
+										{:else if u.status === 'uploading'}
+											<LoaderCircle class="h-4 w-4 shrink-0 animate-spin text-muted-foreground" />
+										{/if}
+									</div>
+									{#if u.status === 'uploading' || u.status === 'pending'}
+										<Progress value={u.progress.current} max={100} class="h-1" />
+									{/if}
+									{#if u.status === 'done' && u.entry}
+										{@const fileKey = u.entry.key}
+										{@const downloadUrl = u.entry.download_url}
+										<div class="mt-1 flex items-center gap-2">
+											<span class="min-w-0 flex-1 truncate text-xs text-muted-foreground"
+												>{downloadUrl}</span
+											>
+											<Button
+												size="sm"
+												variant="ghost"
+												class="h-6 shrink-0 px-2 text-xs"
+												onclick={() => copyDownloadLink(fileKey, downloadUrl)}
+											>
+												{#if copiedFileKeys.has(fileKey)}
+													<Check class="mr-1 h-3 w-3 text-green-500" />
+													Copied
+												{:else}
+													<Copy class="mr-1 h-3 w-3" />
+													Copy
+												{/if}
+											</Button>
+											<a href={downloadUrl} target="_blank" rel="noopener noreferrer">
+												<Button size="sm" variant="outline" class="h-6 shrink-0 px-2 text-xs">
+													<Download class="mr-1 h-3 w-3" />
+													Download
+												</Button>
+											</a>
+										</div>
+									{/if}
+								</div>
+							{/each}
+						</div>
+					{/if}
+				</CardContent>
+				<CardFooter>
+					<Button
+						onclick={uploadAll}
+						disabled={pendingFiles.length === 0 || isUploading}
+						class="w-full"
+					>
+						{#if isUploading}
+							<LoaderCircle class="mr-2 h-4 w-4 animate-spin" />
+							Uploading…
+						{:else}
+							<Upload class="mr-2 h-4 w-4" />
+							Upload {pendingFiles.length > 0
+								? `${pendingFiles.length} file${pendingFiles.length > 1 ? 's' : ''}`
+								: 'Files'}
+						{/if}
+					</Button>
+				</CardFooter>
+			</Card>
+		{/if}
+
+		<!-- ── Client: active stream progress ── -->
+		{#if !isHost && receiveState.type === 'streaming'}
+			<Card>
+				<CardHeader>
+					<CardTitle class="flex items-center gap-2 text-base">
+						<LoaderCircle class="h-4 w-4 animate-spin" />
+						Receiving: {receiveState.filename}
+					</CardTitle>
+				</CardHeader>
+				<CardContent class="space-y-2">
+					<div class="flex justify-between text-xs">
+						<span class="text-muted-foreground">
+							{formatFileSize(receiveState.received)} / {formatFileSize(receiveState.size)}
+						</span>
+						<span class="text-muted-foreground">{streamProgress.toFixed(0)}%</span>
+					</div>
+					<Progress value={streamProgress} max={100} />
+				</CardContent>
+			</Card>
+		{/if}
+
+		<!-- ── Shared files list ── -->
+		<Card>
+			<CardHeader>
+				<CardTitle class="flex items-center justify-between text-base">
+					<span class="flex items-center gap-2">
+						<Users class="h-4 w-4" />
+						{isHost ? 'Shared Files' : 'Available Files'}
+					</span>
+					<Badge variant="outline">{roomFiles.length}</Badge>
+				</CardTitle>
+				{#if !isHost}
+					<CardDescription>
+						Files are streamed to you automatically. Use the download links to save them — links
+						remain valid until the room expires.
+					</CardDescription>
+				{/if}
+			</CardHeader>
+			<CardContent>
+				{#if roomFiles.length === 0}
+					<div class="flex flex-col items-center gap-2 py-8 text-sm text-muted-foreground">
+						<FileIcon class="h-8 w-8 opacity-40" />
+						<span>{isHost ? 'No files uploaded yet.' : 'Waiting for host to share files…'}</span>
+					</div>
+				{:else}
+					<div class="space-y-2">
+						{#each roomFiles as f}
+							{@const downloaded = downloadedFiles.find((d) => d.key === f.key)}
+							<div class="rounded-md border px-3 py-2">
+								<div class="flex items-center gap-3">
+									<FileIcon class="h-4 w-4 shrink-0 text-muted-foreground" />
+									<div class="min-w-0 flex-1">
+										<p class="truncate text-sm font-medium">{f.filename}</p>
+										<p class="text-xs text-muted-foreground">{formatFileSize(f.size)}</p>
+									</div>
+
+									<!-- Copy permanent link -->
+									<Tooltip.Provider>
+										<Tooltip.Root>
+											<Tooltip.Trigger>
+												<Button
+													size="sm"
+													variant="ghost"
+													class="h-7 shrink-0 px-2"
+													onclick={() => copyDownloadLink(f.key, fileDownloadUrl(f.key))}
+												>
+													{#if copiedFileKeys.has(f.key)}
+														<Check class="h-3.5 w-3.5 text-green-500" />
+													{:else}
+														<Copy class="h-3.5 w-3.5" />
+													{/if}
+												</Button>
+											</Tooltip.Trigger>
+											<Tooltip.Content>Copy permanent download link</Tooltip.Content>
+										</Tooltip.Root>
+									</Tooltip.Provider>
+
+									<!-- Permanent HTTP download -->
+									{#if f.key}
+										<a href={fileDownloadUrl(f.key)} target="_blank" rel="noopener noreferrer">
+											<Button size="sm" variant="outline" class="h-7 shrink-0 gap-1 px-2 text-xs">
+												<Download class="h-3.5 w-3.5" />
+												Download
+											</Button>
+										</a>
+									{/if}
+
+									<!-- Client: save streamed blob -->
+									{#if !isHost && downloaded?.objectUrl}
+										<a
+											href={downloaded.objectUrl}
+											download={downloaded.filename}
+											rel="noopener noreferrer"
+										>
+											<Button size="sm" variant="default" class="h-7 shrink-0 gap-1 px-2 text-xs">
+												<Check class="h-3.5 w-3.5" />
+												Saved
+											</Button>
+										</a>
+									{/if}
+								</div>
+							</div>
+						{/each}
+					</div>
+				{/if}
+			</CardContent>
+		</Card>
+
+		<!-- ── Client: received blobs ── -->
+		{#if !isHost && downloadedFiles.length > 0}
+			<Card>
+				<CardHeader>
+					<CardTitle class="text-base">Received Files</CardTitle>
+					<CardDescription>
+						Files streamed to you this session. "Save" downloads from browser memory, "Permalink"
+						fetches from the server link — which remains valid until the room expires.
+					</CardDescription>
+				</CardHeader>
+				<CardContent>
+					<div class="space-y-2">
+						{#each downloadedFiles as df}
+							<div class="flex items-center gap-3 rounded-md border px-3 py-2">
+								<Check class="h-4 w-4 shrink-0 text-green-500" />
+								<div class="min-w-0 flex-1">
+									<p class="truncate text-sm font-medium">{df.filename}</p>
+									<p class="text-xs text-muted-foreground">{formatFileSize(df.size)}</p>
+								</div>
+								{#if df.objectUrl}
+									<a href={df.objectUrl} download={df.filename}>
+										<Button size="sm" variant="default" class="h-7 shrink-0 gap-1 px-2 text-xs">
+											<Download class="h-3.5 w-3.5" />
+											Save
+										</Button>
+									</a>
+								{/if}
+								{#if df.key}
+									<a href={fileDownloadUrl(df.key)} target="_blank" rel="noopener noreferrer">
+										<Button size="sm" variant="outline" class="h-7 shrink-0 gap-1 px-2 text-xs">
+											<Link class="h-3.5 w-3.5" />
+											Permalink
+										</Button>
+									</a>
+								{/if}
+							</div>
+						{/each}
+					</div>
+				</CardContent>
+			</Card>
+		{/if}
+	</div>
+{/if}
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/[room_id]/+page.ts b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/[room_id]/+page.ts
new file mode 100644
index 00000000..42a828c1
--- /dev/null
+++ b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/reverse/[room_id]/+page.ts
@@ -0,0 +1 @@
+export const trailingSlash = 'ignore';
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/+page.svelte b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/+page.svelte
similarity index 100%
rename from src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/+page.svelte
rename to src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/+page.svelte
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/+page.ts b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/+page.ts
similarity index 100%
rename from src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/+page.ts
rename to src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/+page.ts
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/recent_upload.svelte b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/recent_upload.svelte
similarity index 100%
rename from src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/recent_upload.svelte
rename to src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/recent_upload.svelte
diff --git a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/upload_showcase.svelte b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/upload_showcase.svelte
similarity index 98%
rename from src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/upload_showcase.svelte
rename to src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/upload_showcase.svelte
index fbe19b59..e80a74ee 100644
--- a/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/(upload)/upload_showcase.svelte
+++ b/src/frontend/src/routes/(needs_onboarding)/(navbar_and_footer)/upload/upload_showcase.svelte
@@ -267,7 +267,7 @@
 						</Tooltip.Root>
 					{/if}
 
-					<!-- Diagonal stripe overlay on active uploads (non-interactive) -->
+					<!-- Diagonal stripe overlay on active uploads -->
 					{#if uploadPcts.length > 0}
 						{@const activeStartPct =
 							finishedPct.current > 0 ? Math.max(finishedPct.current, MIN_SEGMENT_PCT) : 0}
@@ -285,7 +285,7 @@
 						></div>
 					{/if}
 
-					<!-- Remaining space tooltip (covers unfilled area) -->
+					<!-- Remaining space tooltip  -->
 					{#if appState.current.total_available_space}
 						{@const filledPct =
 							(finishedPct.current > 0 ? Math.max(finishedPct.current, MIN_SEGMENT_PCT) : 0) +