From 317313a08d215feedab6f36ac2f22c03d703ecc9 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Wed, 30 Sep 2026 14:19:07 -0700
Subject: [PATCH 01/43] [API] Add client file selection on IClientWindow

Apps request a file through the UI loop and read bytes from SelectedFilesUserInputEvent, so native, WebRTC, and MP4 share one contract instead of a host-path picker.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |   6 +-
 .../flashdreams/api_v2/client_window.py       |  16 +++
 flashdreams/flashdreams/api_v2/loop.py        |  61 +++++++-
 .../runtime_v2/mp4_client_window.py           |  36 ++++-
 .../runtime_v2/native_window_client_window.py | 108 +++++++++++++++
 .../flashdreams/runtime_v2/serving/web/app.js |  27 ++++
 .../runtime_v2/serving/webrtc_server.py       | 101 +++++++++++++-
 .../flashdreams/runtime_v2/session_runner.py  |   4 +
 .../runtime_v2/user_input_event.py            |  34 +++++
 .../runtime_v2/webrtc_client_window.py        |  26 +++-
 .../test_native_window_client_window.py       |  68 +++++++++
 flashdreams/test_v2/test_selected_files.py    |  88 ++++++++++++
 flashdreams/test_v2/test_session_runner.py    |  26 ++++
 .../test_v2/test_webrtc_client_window.py      |  47 ++++++-
 integrations_v2/imgui_ui_demo/README.md       |  11 ++
 .../imgui_ui_demo/imgui_ui_demo/__init__.py   |   3 +
 .../imgui_ui_demo/file_picker_app.py          | 131 ++++++++++++++++++
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  74 ++++++++++
 integrations_v2/imgui_ui_demo/pyproject.toml  |   1 +
 19 files changed, 860 insertions(+), 8 deletions(-)
 create mode 100644 flashdreams/test_v2/test_selected_files.py
 create mode 100644 integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 5670024b1..f8b8a91de 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -210,7 +210,11 @@ exposes `imgui_bundle.imgui` and an image-like pixel upload convenience form. A
 UI control that needs a fresh application session calls
 `request_new_session(session_desc)` with a fully resolved replacement
 description; the runtime cleans the current session and passes that description
-to `ApplicationRunner` unchanged.
+to `ApplicationRunner` unchanged. A control that needs a file from the client
+calls `request_selected_files(request_id)`; the window later reports
+`SelectedFilesUserInputEvent` through the same input stream as keyboard and
+mouse. The application reads file bytes from that event and does not open a
+host path.
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
 [`slangpy_ui_demo` integration](../../../integrations_v2/slangpy_ui_demo/README.md)
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 1a2dd1754..936f4a7cf 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -46,3 +46,19 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
             new_window_size: Requested ``(width, height)`` in pixels.
         """
         pass
+
+    # Optional to implement
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Ask this client to pick files and report them as input events.
+
+        The chosen files arrive later through
+        :meth:`InputSource.get_user_input_events`.
+
+        Args:
+            request_id: Correlation token for the later input event.
+            initial_path: Directory the selector should start in; ``None`` lets
+                the window choose a default.
+        """
+        pass
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 56740c09c..916b32f5a 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -10,8 +10,9 @@
 import time
 from abc import ABC, abstractmethod
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generic, TypeVar, final
 
 from torch import Tensor
@@ -61,6 +62,17 @@ class _Message(Generic[StateT]):
     """Operation to run before the loop's next step."""
 
 
+@dataclass(frozen=True, slots=True)
+class FileSelectionRequest:
+    """One client file-selector request queued by a UI loop."""
+
+    request_id: str
+    """Correlation token for the later selected-files input event."""
+
+    initial_path: str
+    """Directory the selector should start in."""
+
+
 @dataclass(slots=True)
 class UILoopRequests:
     """Changes requested by a UI loop for the session runtime to apply.
@@ -80,6 +92,9 @@ class UILoopRequests:
     new_window_size: tuple[int, int] | None = None
     """Requested downstream window size, or ``None`` to leave it unchanged."""
 
+    file_selections: list[FileSelectionRequest] = field(default_factory=list)
+    """File-selector requests to apply, in the order they were queued."""
+
 
 class ILoop(ABC, Generic[StateT]):
     """Shared state, messaging, and lifecycle for a session loop.
@@ -466,6 +481,49 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
             raise ValueError("new_window_size dimensions must be > 0.")
         self.get_or_create_ui_loop_requests().new_window_size = new_window_size
 
+    @final
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Ask the client window to open a file selector.
+
+        The window reports the result later as
+        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
+
+        Args:
+            request_id: Correlation token for the later input event.
+            initial_path: Directory the selector should start in; ``None`` uses
+                the current user's home directory.
+
+        Raises:
+            TypeError: ``request_id`` or ``initial_path`` is not a string.
+            ValueError: ``request_id`` is empty, ``initial_path`` is empty, or
+                ``request_id`` is already queued in this UI step.
+        """
+        if not isinstance(request_id, str):
+            raise TypeError("request_id must be a string.")
+        if not request_id:
+            raise ValueError("request_id must be a non-empty string.")
+        if initial_path is None:
+            resolved_initial_path = str(Path.home())
+        else:
+            if not isinstance(initial_path, str):
+                raise TypeError("initial_path must be a string.")
+            if not initial_path:
+                raise ValueError("initial_path must be a non-empty string.")
+            resolved_initial_path = initial_path
+        requests = self.get_or_create_ui_loop_requests()
+        if any(
+            selection.request_id == request_id for selection in requests.file_selections
+        ):
+            raise ValueError(f"Duplicate file-selection request id {request_id!r}.")
+        requests.file_selections.append(
+            FileSelectionRequest(
+                request_id=request_id,
+                initial_path=resolved_initial_path,
+            )
+        )
+
     def get_or_create_ui_loop_requests(self) -> UILoopRequests:
         if self._ui_loop_requests is None:
             self._ui_loop_requests = UILoopRequests()
@@ -561,6 +619,7 @@ def invoke_async(loop: ILoop[StateT], operation: Callable[[StateT], None]) -> No
 
 
 __all__ = [
+    "FileSelectionRequest",
     "ILoop",
     "IModelLoop",
     "IUILoop",
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index 3e2c72ac6..8784d02f5 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -5,19 +5,28 @@
 
 from pathlib import Path
 
+from numpy import uint64
+
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_event import (
+    SelectedFilesUserInputEvent,
+    UserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
 class Mp4ClientWindow(IClientWindow):
-    """Write UI frames to an MP4 file and report no input.
+    """Write UI frames to an MP4 file.
 
     The session must finish on its own because this window never sends a close
     event. Use ``BackpressureMode.BLOCK`` with
     ``PresentationMode.ON_DEMAND`` to write every frame once.
+
+    File-selector requests complete immediately with no files; there is no
+    client to pick one.
     """
 
     def __init__(self, path: str | Path) -> None:
@@ -27,6 +36,7 @@ def __init__(self, path: str | Path) -> None:
         """
         self._path = Path(path)
         self._video_sink = Mp4OutputSink(path)
+        self._pending_events: list[UserInputEvent] = []
 
     @property
     def path(self) -> Path:
@@ -34,8 +44,28 @@ def path(self) -> Path:
         return self._path
 
     def get_user_input_events(self) -> UserInputEvents:
-        """Return an empty input batch."""
-        return UserInputEvents([])
+        """Return file-selector results queued since the previous poll."""
+        events = self._pending_events
+        self._pending_events = []
+        return UserInputEvents(events)
+
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Complete a file-selector request with no files.
+
+        Args:
+            request_id: Correlation token from the UI loop.
+            initial_path: Ignored; an MP4 has no selector.
+        """
+        del initial_path
+        self._pending_events.append(
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=request_id,
+                files=(),
+            )
+        )
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the MP4 presentation dimensions without replacing the session.
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 3c73881d2..b83e37108 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -7,11 +7,15 @@
 
 import logging
 import queue
+import shutil
+import subprocess
+import sys
 import threading
 import time
 from collections import deque
 from collections.abc import Callable
 from dataclasses import replace
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
 import numpy as np
@@ -29,6 +33,8 @@
     KeyboardInputState,
     KeyboardUserInputEvent,
     MouseUserInputEvent,
+    SelectedFile,
+    SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -38,6 +44,69 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+
+def _ask_open_filename(*, initial_dir: str) -> str:
+    """Return a path from the OS file picker, or ``""`` when cancelled."""
+    if sys.platform.startswith("linux"):
+        return _ask_open_filename_linux(initial_dir=initial_dir)
+    return _ask_open_filename_tkinter(initial_dir=initial_dir)
+
+
+def _ask_open_filename_linux(*, initial_dir: str) -> str:
+    """Open the desktop file picker via ``zenity`` or ``kdialog``.
+
+    ``zenity --file-selection`` uses ``GtkFileChooserNative``, which is the
+    xdg-desktop-portal chooser. The helper is a separate process so the
+    GLFW window does not host GTK.
+    """
+    directory = str(Path(initial_dir))
+    zenity = shutil.which("zenity")
+    if zenity is not None:
+        argv = [
+            zenity,
+            "--file-selection",
+            f"--filename={directory}/",
+            "--title=Select a file",
+        ]
+    else:
+        kdialog = shutil.which("kdialog")
+        if kdialog is None:
+            raise RuntimeError(
+                "Native file picker needs a desktop chooser (zenity or kdialog)."
+            )
+        argv = [kdialog, "--getopenfilename", directory]
+    completed = subprocess.run(
+        argv,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        return ""
+    return completed.stdout.strip()
+
+
+def _ask_open_filename_tkinter(*, initial_dir: str) -> str:
+    """Open the Tk file dialog (native Explorer / macOS panel)."""
+    import tkinter as tk
+    from tkinter import filedialog
+
+    root = tk.Tk()
+    root.withdraw()
+    try:
+        root.attributes("-topmost", True)
+    except tk.TclError:
+        pass
+    try:
+        selected = filedialog.askopenfilename(
+            initialdir=initial_dir,
+            title="Select a file",
+        )
+    finally:
+        root.destroy()
+    return str(selected or "")
+
+
 _PRINTABLE_KEY_NAMES = {
     "space": " ",
     "apostrophe": "'",
@@ -126,6 +195,7 @@ def __init__(
         self._pressed_key_values: dict[str, str] = {}
         self._hide_cursor = False
         self._lock_cursor_to_window = False
+        self._in_flight_file_requests: set[str] = set()
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the native window."""
@@ -164,6 +234,44 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
             )
         self._window_size = presenter.resize(*new_window_size)
 
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Open a native OS file selector and enqueue the chosen file.
+
+        Args:
+            request_id: Correlation token for the later input event.
+            initial_path: Directory the selector should start in; ``None`` uses
+                the current user's home directory.
+
+        Raises:
+            ValueError: ``request_id`` is already waiting for a selector.
+        """
+        if request_id in self._in_flight_file_requests:
+            raise ValueError(f"Duplicate file-selection request id {request_id!r}.")
+        self._in_flight_file_requests.add(request_id)
+        try:
+            selected = _ask_open_filename(
+                initial_dir=initial_path or str(Path.home()),
+            )
+            files: tuple[SelectedFile, ...] = ()
+            if selected:
+                path = Path(selected)
+                try:
+                    data = path.read_bytes()
+                except OSError:
+                    data = b""
+                files = (SelectedFile(name=path.name, path=str(path), data=data),)
+            self._put_input(
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=request_id,
+                    files=files,
+                )
+            )
+        finally:
+            self._in_flight_file_requests.discard(request_id)
+
     def open(self, session_desc: SessionDesc) -> None:
         """Create the GLFW window on the runtime's UI thread.
 
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index d8e10c3e5..998b403a1 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -74,6 +74,29 @@ const applyCursorOptions = options => {
   }
 };
 
+const openFileSelector = options => {
+  const requestId = options?.id;
+  if (typeof requestId !== "string" || !requestId) {
+    return;
+  }
+  const input = document.createElement("input");
+  input.type = "file";
+  input.addEventListener("change", () => {
+    const file = input.files?.[0];
+    if (!file) {
+      send({type: "file_selector_result", id: requestId, cancelled: true});
+      return;
+    }
+    const body = new FormData();
+    body.append("request_id", requestId);
+    body.append("file", file, file.name);
+    fetch("/api/files", {method: "POST", body}).catch(error => {
+      console.debug("Unable to upload the selected file.", error);
+    });
+  });
+  input.click();
+};
+
 window.addEventListener("focus", updateCursorVisibility);
 window.addEventListener("blur", updateCursorVisibility);
 
@@ -87,6 +110,10 @@ controls.addEventListener("message", event => {
       applyCursorOptions(payload);
       return;
     }
+    if (payload?.type === "file_selector") {
+      openFileSelector(payload);
+      return;
+    }
     if (payload?.type === "error") {
       console.warn(`WebRTC server: ${payload.message ?? "unknown error"}`);
     }
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 721959f85..fd23e24e4 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -16,11 +16,13 @@
 from dataclasses import dataclass
 from fractions import Fraction
 from importlib.resources import files
+from pathlib import Path
 from typing import Any, Literal, cast
 
 import numpy as np
 import torch
 from aiohttp import web
+from aiohttp.web_request import FileField
 from aiortc import MediaStreamTrack, RTCPeerConnection, RTCSessionDescription
 from aiortc.mediastreams import MediaStreamError
 from av import VideoFrame
@@ -40,6 +42,8 @@
     MouseUserInputEvent,
     QueryStringUserInputEvent,
     ResetUserInputEvent,
+    SelectedFile,
+    SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     UserInputEvent,
     XRControllerUserInputEvent,
@@ -53,6 +57,9 @@
 _INTERACTIVE_FRAME_QUEUE_SIZE = 2
 """Send-ready frames retained while the media sender is temporarily busy."""
 
+_MAX_SELECTED_FILE_BYTES = 32 * 1024 * 1024
+"""Maximum file the browser may upload for one selected-files event."""
+
 _TRANSFER_STREAM_PRIORITY = -1
 """Portable high-priority CUDA stream request for interactive output copies."""
 
@@ -346,6 +353,7 @@ def __init__(
         self._client_connected = False
         self._hide_cursor = False
         self._lock_cursor_to_window = False
+        self._queued_file_selectors: list[dict[str, str]] = []
         self._thread = threading.Thread(
             target=self._run_server,
             name="flashdreams-webrtc",
@@ -436,6 +444,49 @@ def _send_cursor_options(self) -> None:
 
         self._sent_cursor_options = cursor_options
 
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Ask the connected browser to open a file selector.
+
+        Args:
+            request_id: Correlation token for the later input event.
+            initial_path: Directory hint for the selector; ``None`` uses the
+                current user's home directory.
+        """
+        if not isinstance(request_id, str) or not request_id:
+            raise ValueError("request_id must be a non-empty string.")
+        if initial_path is None:
+            resolved_initial_path = str(Path.home())
+        elif not isinstance(initial_path, str) or not initial_path:
+            raise ValueError("initial_path must be a non-empty string.")
+        else:
+            resolved_initial_path = initial_path
+        payload = {
+            "type": "file_selector",
+            "id": request_id,
+            "initial_path": resolved_initial_path,
+        }
+        loop = self._loop
+        if loop is None:
+            raise RuntimeError("WebRTC server is not running.")
+        loop.call_soon_threadsafe(self._send_file_selector, payload)
+
+    def _send_file_selector(self, payload: dict[str, str]) -> None:
+        """Send one file-selector request on the WebRTC event-loop thread."""
+        channel = self._control_channel
+        if channel is None or channel.readyState != "open":
+            self._queued_file_selectors.append(payload)
+            return
+        channel.send(json.dumps(payload))
+
+    def _flush_queued_file_selectors(self) -> None:
+        """Send file-selector requests that arrived before the datachannel opened."""
+        queued = self._queued_file_selectors
+        self._queued_file_selectors = []
+        for payload in queued:
+            self._send_file_selector(payload)
+
     def event_timestamp_us(self) -> np.uint64:
         """Return the current timestamp relative to this server's first session.
 
@@ -720,11 +771,12 @@ def _run_server(self) -> None:
     async def _start_server(self) -> None:
         """Create and bind the standalone aiohttp application."""
         self._offer_lock = asyncio.Lock()
-        app = web.Application()
+        app = web.Application(client_max_size=_MAX_SELECTED_FILE_BYTES + 1024 * 1024)
         app.router.add_get("/", self._serve_browser)
         app.router.add_get("/app.js", self._serve_browser_script)
         app.router.add_get("/healthz", self._health)
         app.router.add_post("/api/webrtc/offer", self._offer)
+        app.router.add_post("/api/files", self._upload_selected_file)
         runner = web.AppRunner(app)
         await runner.setup()
         address_family = socket.AF_INET6 if ":" in self._host else socket.AF_INET
@@ -762,6 +814,36 @@ async def _health(self, _: web.Request) -> web.Response:
             }
         )
 
+    async def _upload_selected_file(self, request: web.Request) -> web.Response:
+        """Turn a browser file upload into a selected-files input event."""
+        if self._closed:
+            raise web.HTTPServiceUnavailable(reason="WebRTC server is closed.")
+        timestamp_us = self._timestamp_us()
+        if timestamp_us is None:
+            raise web.HTTPConflict(reason="WebRTC server is not open.")
+        post = await request.post()
+        request_id = post.get("request_id")
+        if not isinstance(request_id, str) or not request_id:
+            raise web.HTTPBadRequest(reason="File upload requires request_id.")
+        upload = post.get("file")
+        if not isinstance(upload, FileField):
+            raise web.HTTPBadRequest(reason="File upload requires a file.")
+        data = upload.file.read()
+        if len(data) > _MAX_SELECTED_FILE_BYTES:
+            raise web.HTTPRequestEntityTooLarge(
+                max_size=_MAX_SELECTED_FILE_BYTES,
+                actual_size=len(data),
+            )
+        name = upload.filename or "upload"
+        self._append_event(
+            SelectedFilesUserInputEvent(
+                timestamp=timestamp_us,
+                request_id=request_id,
+                files=(SelectedFile(name=name, path=name, data=data),),
+            )
+        )
+        return web.Response(status=204)
+
     async def _offer(self, request: web.Request) -> web.Response:
         """Negotiate one browser peer connection."""
         if self._closed:
@@ -815,12 +897,14 @@ def on_datachannel(channel: Any) -> None:
                     def on_open() -> None:
                         if self._peer_connection is peer_connection:
                             self._send_cursor_options()
+                            self._flush_queued_file_selectors()
 
                     if (
                         self._peer_connection is peer_connection
                         and channel.readyState == "open"
                     ):
                         self._send_cursor_options()
+                        self._flush_queued_file_selectors()
 
                 @channel.on("message")
                 def on_message(message: Any) -> None:
@@ -903,6 +987,7 @@ async def on_connectionstatechange() -> None:
             self._sent_cursor_options = None
             if control_channel is not None and control_channel.readyState == "open":
                 self._send_cursor_options()
+                self._flush_queued_file_selectors()
             query_string = request.rel_url.raw_query_string
             if query_string:
                 timestamp_us = self._timestamp_us()
@@ -1080,6 +1165,20 @@ def _buffer_browser_message(
             event = ResetUserInputEvent(timestamp=timestamp_us)
         elif event_type == "close":
             event = CloseUserInputEvent(timestamp=timestamp_us)
+        elif event_type == "file_selector_result":
+            request_id = payload.get("id")
+            if not isinstance(request_id, str) or not request_id:
+                raise ValueError("File selector result requires a non-empty id.")
+            if payload.get("cancelled") is not True:
+                raise ValueError(
+                    "File selector result must set cancelled true; send files "
+                    "with POST /api/files."
+                )
+            event = SelectedFilesUserInputEvent(
+                timestamp=timestamp_us,
+                request_id=request_id,
+                files=(),
+            )
         else:
             raise ValueError("Unsupported browser event type.")
         self._append_event(event)
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index afab47e7f..30a2a2fd5 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -143,6 +143,10 @@ def run_ui_once(*, step_requested: bool = True) -> None:
                         )
                     if request.new_window_size is not None:
                         window.request_new_window_size(request.new_window_size)
+                    for selection in request.file_selections:
+                        window.request_selected_files(
+                            selection.request_id, selection.initial_path
+                        )
                     if request.new_session is not None:
                         next_session_desc = request.new_session
                         stop.set()
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 4190efae1..13674d5c5 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -230,6 +230,40 @@ def get_type_name(cls) -> str:
     """Optional controller quaternion in client XR space."""
 
 
+@dataclass(frozen=True, slots=True)
+class SelectedFile:
+    """One file chosen by a client file selector."""
+
+    name: str
+    """File name shown to the application, without requiring a host path."""
+
+    path: str
+    """Native host path, or the file name when the client has no path."""
+
+    data: bytes
+    """File contents. Applications should use this rather than opening ``path``."""
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class SelectedFilesUserInputEvent(UserInputEvent):
+    """Files chosen for one :meth:`IClientWindow.request_selected_files` call.
+
+    An empty ``files`` tuple is a cancelled or unavailable selector, including
+    ``--mode mp4`` where no client can pick a file.
+    """
+
+    @classmethod
+    def get_type_name(cls) -> str:
+        """Return the event type name."""
+        return "selected_files"
+
+    request_id: str
+    """Identifier supplied with the matching file-selection request."""
+
+    files: tuple[SelectedFile, ...] = ()
+    """Chosen files, empty when the selector was cancelled or unavailable."""
+
+
 @dataclass(frozen=True, slots=True, eq=False)
 class UnknownUserInputEvent(UserInputEvent):
     """User input event for an unknown input modality."""
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 8eaa9b809..320df157c 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -13,7 +13,10 @@
 from flashdreams.runtime_v2.serving.webrtc_server import WebRTCServer
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import UserInputEvent
+from flashdreams.runtime_v2.user_input_event import (
+    SelectedFilesUserInputEvent,
+    UserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
@@ -55,6 +58,7 @@ def __init__(
         self._input_events: deque[UserInputEvent] = deque()
         self._hide_cursor = False
         self._lock_cursor_to_window = False
+        self._in_flight_file_requests: set[str] = set()
         self._input_lock = threading.Lock()
         # Offset from the server's stable clock to the current session's clock.
         self._session_event_offset_us = uint64(0)
@@ -68,6 +72,8 @@ def handle_input(event: UserInputEvent) -> None:
             """Buffer one backend event for the ``InputSource`` protocol."""
             # TODO: do we really need to buffer all events? Some mouse moves may be superseded by later ones.
             with self._input_lock:
+                if isinstance(event, SelectedFilesUserInputEvent):
+                    self._in_flight_file_requests.discard(event.request_id)
                 self._input_events.append(event)
 
         self.server.register_input_callback(handle_input)
@@ -100,6 +106,24 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         self.server.request_new_window_size(new_window_size)
 
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Ask the connected browser to open a file selector.
+
+        Args:
+            request_id: Correlation token for the later input event.
+            initial_path: Directory hint for the selector; browsers may ignore
+                it. ``None`` uses the current user's home directory.
+
+        Raises:
+            ValueError: ``request_id`` is already waiting for a selector.
+        """
+        if request_id in self._in_flight_file_requests:
+            raise ValueError(f"Duplicate file-selection request id {request_id!r}.")
+        self._in_flight_file_requests.add(request_id)
+        self.server.request_selected_files(request_id, initial_path=initial_path)
+
     def open(self, session_desc: SessionDesc) -> None:
         """Implement ``OutputSink.open`` by configuring WebRTC output.
 
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 4f327fb01..c039ed928 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -8,6 +8,7 @@
 import queue
 import threading
 from collections.abc import Callable, Sequence
+from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, cast
 from unittest.mock import Mock
@@ -27,6 +28,7 @@
     KeyboardInputState,
     KeyboardUserInputEvent,
     MouseUserInputEvent,
+    SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
@@ -585,6 +587,72 @@ def create_presenter(**kwargs: object) -> _Presenter:
     assert (unlocked_mouse.x, unlocked_mouse.y) == (1.0, 0.0)
 
 
+def test_native_window_reports_a_selected_file(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    chosen = tmp_path / "seed.png"
+    chosen.write_bytes(b"png-bytes")
+    monkeypatch.setattr(
+        native_window_module,
+        "_ask_open_filename",
+        lambda *, initial_dir: str(chosen),
+    )
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    events = window.get_user_input_events().get_events()
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.files[0].name == "seed.png"
+    assert event.files[0].path == str(chosen)
+    assert event.files[0].data == b"png-bytes"
+
+
+def test_ask_open_filename_linux_uses_zenity(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+
+    def fake_run(argv: list[str], **kwargs: object) -> object:
+        assert argv[0] == "/usr/bin/zenity"
+        assert "--file-selection" in argv
+        assert any(arg.startswith("--filename=/tmp/") for arg in argv)
+        return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
+
+    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    assert (
+        native_window_module._ask_open_filename_linux(initial_dir="/tmp")
+        == "/tmp/seed.png"
+    )
+
+
+def test_ask_open_filename_linux_cancel_is_empty(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+    monkeypatch.setattr(
+        native_window_module.subprocess,
+        "run",
+        lambda argv, **kwargs: SimpleNamespace(returncode=1, stdout=""),
+    )
+    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == ""
+
+
 def test_native_window_reports_standard_gamepad_events() -> None:
     presenter = _Presenter()
     clock_values = iter((1_000_000, 1_001_000, 1_002_000, 1_003_000))
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
new file mode 100644
index 000000000..2e156b2de
--- /dev/null
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -0,0 +1,88 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""CPU tests for client file selection through the v2 window contract."""
+
+import queue
+import threading
+from pathlib import Path
+
+import pytest
+from numpy import uint64
+
+from flashdreams.api_v2.loop import IUILoop
+from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
+from flashdreams.runtime_v2.presentation_manager import PresentationManager
+from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_event import (
+    SelectedFile,
+    SelectedFilesUserInputEvent,
+)
+from flashdreams.runtime_v2.user_input_events import UserInputEvents
+
+pytestmark = pytest.mark.ci_cpu
+
+
+class _UILoop(IUILoop[None]):
+    def step(self, step_index: int, events: UserInputEvents) -> StepResult | None:
+        del step_index, events
+        return None
+
+    def reset(self) -> None:
+        return
+
+
+def _ui_loop() -> _UILoop:
+    loop = _UILoop()
+    loop.register_session_loop_objects(
+        state=None,
+        frequency=0,
+        shutdown_event=threading.Event(),
+        failure_queue=queue.Queue(),
+    )
+    loop.register_session_ui_loop_objects(
+        session_desc=SessionDesc(),
+        presentation_manager=PresentationManager(),
+    )
+    return loop
+
+
+def test_selected_files_event_carries_bytes_and_request_id() -> None:
+    event = SelectedFilesUserInputEvent(
+        timestamp=uint64(1),
+        request_id="open-1",
+        files=(SelectedFile(name="seed.png", path="/tmp/seed.png", data=b"png"),),
+    )
+
+    assert event.get_type_name() == "selected_files"
+    assert event.request_id == "open-1"
+    assert event.files[0].data == b"png"
+
+
+def test_ui_loop_queues_file_selection_and_rejects_duplicate_ids() -> None:
+    loop = _ui_loop()
+    loop.request_selected_files("open-1", "/tmp")
+
+    with pytest.raises(ValueError, match="Duplicate file-selection request id"):
+        loop.request_selected_files("open-1", "/var")
+
+    requests = loop.flush_ui_loop_requests()
+    assert requests is not None
+    assert len(requests.file_selections) == 1
+    assert requests.file_selections[0].request_id == "open-1"
+    assert requests.file_selections[0].initial_path == "/tmp"
+
+
+def test_mp4_window_completes_file_selection_with_no_files(tmp_path: Path) -> None:
+    window = Mp4ClientWindow(tmp_path / "clip.mp4")
+    window.request_selected_files("open-1", "/tmp")
+
+    events = window.get_user_input_events().get_events()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.files == ()
+    assert window.get_user_input_events().get_events() == []
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index 90fe8751b..43b673119 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -659,6 +659,7 @@ def __init__(
         self.session_desc: SessionDesc | None = None
         self.results: list[StepResult] = []
         self.cursor_requests: list[tuple[str, bool]] = []
+        self.file_selection_requests: list[tuple[str, str | None]] = []
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Record one cursor visibility request."""
@@ -670,6 +671,13 @@ def request_lock_cursor_to_window(self, lock_cursor_to_window: bool) -> None:
         self._log.record("window.request_lock_cursor_to_window")
         self.cursor_requests.append(("lock", lock_cursor_to_window))
 
+    def request_selected_files(
+        self, request_id: str, initial_path: str | None = None
+    ) -> None:
+        """Record one file-selector request."""
+        self._log.record("window.request_selected_files")
+        self.file_selection_requests.append((request_id, initial_path))
+
     def get_user_input_events(self) -> UserInputEvents:
         self._log.record("window.get_user_input_events")
         with self._lock:
@@ -1364,6 +1372,24 @@ def init(self) -> None:
     assert "window.close" not in log.calls
 
 
+def test_run_session_forwards_file_selection_requests_to_the_window() -> None:
+    log = CallLog()
+
+    class RequestingSession(FakeSession):
+        def init(self) -> None:
+            super().init()
+            invoke_async(
+                self.ui_loop,
+                lambda _: self.ui_loop.request_selected_files("open-1", "/tmp"),
+            )
+
+    window = RecordingClientWindow(log)
+    run_session(RequestingSession(_session_desc(), log), window, steps=1)
+
+    assert window.file_selection_requests == [("open-1", "/tmp")]
+    assert "window.request_selected_files" in log.calls
+
+
 def test_interactive_ui_can_replace_an_already_finished_session() -> None:
     log = CallLog()
 
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index fb3435860..812f4875e 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -20,7 +20,7 @@
 pytest.importorskip("aiohttp")
 pytest.importorskip("aiortc")
 
-from aiohttp import ClientSession
+from aiohttp import ClientSession, FormData
 from aiortc import (
     MediaStreamTrack,
     RTCDataChannel,
@@ -43,6 +43,7 @@
     KeyboardUserInputEvent,
     MouseUserInputEvent,
     QueryStringUserInputEvent,
+    SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     XRControllerUserInputEvent,
 )
@@ -141,6 +142,47 @@ async def test_browser_query_string_reaches_the_input_stream() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_browser_file_upload_reaches_the_input_stream() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", "/tmp")
+        with pytest.raises(ValueError, match="Duplicate file-selection request id"):
+            window.request_selected_files("open-1", "/tmp")
+
+        form = FormData()
+        form.add_field("request_id", "open-1")
+        form.add_field(
+            "file",
+            b"hello",
+            filename="hello.txt",
+            content_type="text/plain",
+        )
+        async with ClientSession() as client:
+            async with client.post(
+                f"{window.server.url}api/files", data=form
+            ) as response:
+                assert response.status == 204
+
+        events = []
+        for _ in range(100):
+            events.extend(window.get_user_input_events().get_events())
+            if events:
+                break
+            await asyncio.sleep(0.01)
+        assert len(events) == 1
+        event = events[0]
+        assert isinstance(event, SelectedFilesUserInputEvent)
+        assert event.request_id == "open-1"
+        assert event.files[0].name == "hello.txt"
+        assert event.files[0].data == b"hello"
+
+        window.request_selected_files("open-1", "/tmp")
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_window_buffers_browser_events_until_drained() -> None:
     window = WebRTCClientWindow()
@@ -215,6 +257,9 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert '["failed", "closed"]' in connection_handler
                 assert "navigator.getGamepads" in browser_script
                 assert 'type: "touch"' in browser_script
+                assert "openFileSelector" in browser_script
+                assert 'type === "file_selector"' in browser_script
+                assert 'fetch("/api/files"' in browser_script
 
         window.request_hide_cursor(True)
         window.open(_session_desc())
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index dcca7516a..50eaa79a9 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -8,6 +8,8 @@ SPDX-License-Identifier: Apache-2.0
 Small ImGui applications for the FlashDreams v2 loop runtime:
 
 - `imgui-ui-text-input` renders an editable text field over model output.
+- `imgui-ui-file-picker` opens the client file selector and shows the chosen
+  name and size (the file bytes are on the event; apps should use those).
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.
@@ -24,6 +26,15 @@ Run the text-input application:
 uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 ```
 
+Run the file-picker application. Native Linux needs `zenity` or `kdialog`
+(the desktop portal picker). Windows and macOS use Tk. WebRTC uses the
+browser picker; uploads larger than 32 MiB are rejected.
+```bash
+uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode native-window
+uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode webrtc \
+  --host 127.0.0.1 --port 8080
+```
+
 Run the query-string application:
 ```bash
 uv run --no-sync flashdreams-run-v2 imgui-ui-query-string \
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/__init__.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/__init__.py
index b3fcbf18f..fa3acf920 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/__init__.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/__init__.py
@@ -3,10 +3,13 @@
 
 """Interactive ImGui UI applications for the v2 loop runtime."""
 
+from .file_picker_app import FilePickerApplication, FilePickerSession
 from .text_input_app import TextInputApplication, TextInputSession, create_app
 from .window_size_app import WindowSizeApplication, WindowSizeSession
 
 __all__ = [
+    "FilePickerApplication",
+    "FilePickerSession",
     "TextInputApplication",
     "TextInputSession",
     "WindowSizeApplication",
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
new file mode 100644
index 000000000..91ce96693
--- /dev/null
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -0,0 +1,131 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""ImGui file-picker application for the v2 loop runtime."""
+
+import uuid
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+from torch import Tensor
+
+from flashdreams.api_v2.application import IApplication
+from flashdreams.api_v2.session import ISession
+from flashdreams.runtime_v2.imgui_ui_loop import ImGuiUILoop
+from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
+from flashdreams.runtime_v2.user_input_events import UserInputEvents
+from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
+
+from .text_input_app import BackgroundModelLoop
+
+
+@dataclass(slots=True)
+class FilePickerState:
+    """Last file-selector result shown by the demo overlay."""
+
+    status: str = "No file selected."
+    """Human-readable status of the last selector result."""
+
+
+class FilePickerImGuiUILoop(ImGuiUILoop[FilePickerState]):
+    """Request a client file pick and display the chosen name and size."""
+
+    def step_ui(
+        self,
+        imgui: Any,
+        step_index: int,
+        events: UserInputEvents,
+    ) -> Tensor | None:
+        """Draw the Open-file control and apply any selected-files events."""
+        del step_index
+        for event in events.get_events():
+            if not isinstance(event, SelectedFilesUserInputEvent):
+                continue
+            if not event.files:
+                self.state.status = "Cancelled."
+                continue
+            chosen = event.files[0]
+            self.state.status = f"{chosen.name} ({len(chosen.data)} bytes)"
+
+        imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
+        imgui.set_next_window_size(imgui.ImVec2(420.0, 130.0), imgui.Cond_.once)
+        imgui.begin("File picker")
+        try:
+            if imgui.button("Open file"):
+                self.request_selected_files(uuid.uuid4().hex)
+            imgui.text(self.state.status)
+        finally:
+            imgui.end()
+        return self.presented_model_frame()
+
+    def reset(self) -> None:
+        """Clear the last selector result for a new generation."""
+        self.state.status = "No file selected."
+        super().reset()
+
+
+class FilePickerSession(ISession):
+    """Run an ImGui file picker over a generated background."""
+
+    def __init__(
+        self,
+        session_desc: SessionDesc,
+        *,
+        device: torch.device | str = "cuda",
+    ) -> None:
+        """Configure one file-picker session.
+
+        Args:
+            session_desc: Output dimensions and loop frequencies.
+            device: Device used for the background model frame.
+        """
+        if session_desc.output_layout is not VideoTensorLayout.tchw:
+            raise ValueError(
+                "The file-picker demo requires tchw output, got "
+                f"{session_desc.output_layout.value}."
+            )
+        self._session_desc = session_desc
+        self._device = device
+
+    @property
+    def session_desc(self) -> SessionDesc:
+        """Return the resolved session description."""
+        return self._session_desc
+
+    def init(self) -> None:
+        """Register the file-picker UI and background model loops."""
+        self.register_ui_loop(
+            FilePickerImGuiUILoop,
+            state=FilePickerState(),
+            width=self._session_desc.video_width,
+            height=self._session_desc.video_height,
+        )
+        self.register_model_loop(
+            BackgroundModelLoop,
+            state=(self._session_desc, self._device),
+        )
+
+
+class FilePickerApplication(IApplication):
+    """Create ImGui UI file-picker sessions."""
+
+    def init(self, commandline_args: Sequence[str]) -> None:
+        """Reject application-specific arguments."""
+        if commandline_args:
+            raise ValueError("The file-picker demo takes no application arguments.")
+
+    def session_desc(self) -> SessionDesc:
+        """Return the demo's established dimensions and rates."""
+        return SessionDesc(video_width=640, video_height=480)
+
+    def create_session(self, session_desc: SessionDesc) -> ISession:
+        """Create one uninitialized file-picker session."""
+        return FilePickerSession(session_desc)
+
+
+def create_app() -> IApplication:
+    """Return a new file-picker application."""
+    return FilePickerApplication()
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index bc31faadf..9763cda37 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -9,10 +9,16 @@
 from unittest.mock import Mock
 
 import pytest
+from numpy import uint64
+from imgui_ui_demo.file_picker_app import FilePickerImGuiUILoop, FilePickerState
 from imgui_ui_demo.text_input_app import TextInputImGuiUILoop, TextInputState
 
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
 from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.user_input_event import (
+    SelectedFile,
+    SelectedFilesUserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 pytestmark = pytest.mark.ci_cpu
@@ -47,3 +53,71 @@ def test_text_input_updates_ui_owned_state() -> None:
     assert state.text == "hello world"
     imgui.text.assert_called_with("Value: hello world")
     imgui.end.assert_called_once_with()
+
+
+def _file_picker_loop() -> tuple[FilePickerState, FilePickerImGuiUILoop]:
+    state = FilePickerState()
+    loop = FilePickerImGuiUILoop(renderer=Mock())
+    loop.register_session_loop_objects(
+        state=state,
+        frequency=60,
+        shutdown_event=threading.Event(),
+        failure_queue=queue.Queue(),
+    )
+    loop.register_session_ui_loop_objects(
+        session_desc=SessionDesc(),
+        presentation_manager=PresentationManager(),
+    )
+    return state, loop
+
+
+def test_open_file_button_requests_a_client_file() -> None:
+    _state, loop = _file_picker_loop()
+    imgui = SimpleNamespace(
+        ImVec2=lambda x, y: (x, y),
+        Cond_=SimpleNamespace(once="once"),
+        set_next_window_pos=Mock(),
+        set_next_window_size=Mock(),
+        begin=Mock(),
+        end=Mock(),
+        text=Mock(),
+        button=Mock(return_value=True),
+    )
+
+    loop.step_ui(imgui, 0, UserInputEvents([]))
+    requests = loop.flush_ui_loop_requests()
+
+    assert requests is not None
+    assert len(requests.file_selections) == 1
+    assert requests.file_selections[0].request_id
+
+
+def test_selected_files_event_updates_file_picker_status() -> None:
+    state, loop = _file_picker_loop()
+    imgui = SimpleNamespace(
+        ImVec2=lambda x, y: (x, y),
+        Cond_=SimpleNamespace(once="once"),
+        set_next_window_pos=Mock(),
+        set_next_window_size=Mock(),
+        begin=Mock(),
+        end=Mock(),
+        text=Mock(),
+        button=Mock(return_value=False),
+    )
+
+    loop.step_ui(
+        imgui,
+        0,
+        UserInputEvents(
+            [
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id="open-1",
+                    files=(SelectedFile(name="seed.png", path="seed.png", data=b"xx"),),
+                )
+            ]
+        ),
+    )
+
+    assert state.status == "seed.png (2 bytes)"
+    imgui.text.assert_called_with("seed.png (2 bytes)")
diff --git a/integrations_v2/imgui_ui_demo/pyproject.toml b/integrations_v2/imgui_ui_demo/pyproject.toml
index 5b1371922..3c1a73e25 100644
--- a/integrations_v2/imgui_ui_demo/pyproject.toml
+++ b/integrations_v2/imgui_ui_demo/pyproject.toml
@@ -16,6 +16,7 @@ dependencies = [
 ]
 
 [project.entry-points."flashdreams.applications_v2"]
+"imgui-ui-file-picker" = "imgui_ui_demo.file_picker_app:create_app"
 "imgui-ui-query-string" = "imgui_ui_demo.query_string_app:create_app"
 "imgui-ui-text-input" = "imgui_ui_demo.text_input_app:create_app"
 "imgui-ui-window-size" = "imgui_ui_demo.window_size_app:create_app"

From fba1dc259991a8932814f03b6330b2d39dd8c02a Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Wed, 30 Sep 2026 14:31:56 -0700
Subject: [PATCH 02/43] Ignore duplicate in-flight file-selection ids instead
 of aborting the session

A reused request id (for example a second Open click while a picker is still open) should keep the original pick so the chosen file can still arrive.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/loop.py             | 14 +++++++++++---
 .../runtime_v2/native_window_client_window.py      |  9 +++++----
 .../flashdreams/runtime_v2/webrtc_client_window.py | 12 ++++++++----
 flashdreams/test_v2/test_selected_files.py         |  6 ++----
 flashdreams/test_v2/test_webrtc_client_window.py   |  3 +--
 5 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 916b32f5a..2503615c7 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import logging
 import queue
 import threading
 import time
@@ -31,6 +32,8 @@
 
 StateT = TypeVar("StateT")
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class ModelInferenceState(Enum):
     """Lifecycle state of model inference observed by the UI loop."""
@@ -489,6 +492,8 @@ def request_selected_files(
 
         The window reports the result later as
         :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
+        A second call with the same ``request_id`` while the first is still
+        queued is ignored so the original picker can still complete.
 
         Args:
             request_id: Correlation token for the later input event.
@@ -497,8 +502,7 @@ def request_selected_files(
 
         Raises:
             TypeError: ``request_id`` or ``initial_path`` is not a string.
-            ValueError: ``request_id`` is empty, ``initial_path`` is empty, or
-                ``request_id`` is already queued in this UI step.
+            ValueError: ``request_id`` is empty or ``initial_path`` is empty.
         """
         if not isinstance(request_id, str):
             raise TypeError("request_id must be a string.")
@@ -516,7 +520,11 @@ def request_selected_files(
         if any(
             selection.request_id == request_id for selection in requests.file_selections
         ):
-            raise ValueError(f"Duplicate file-selection request id {request_id!r}.")
+            _LOGGER.warning(
+                "Ignoring duplicate file-selection request id %r.",
+                request_id,
+            )
+            return
         requests.file_selections.append(
             FileSelectionRequest(
                 request_id=request_id,
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index b83e37108..dd01d56a0 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -243,12 +243,13 @@ def request_selected_files(
             request_id: Correlation token for the later input event.
             initial_path: Directory the selector should start in; ``None`` uses
                 the current user's home directory.
-
-        Raises:
-            ValueError: ``request_id`` is already waiting for a selector.
         """
         if request_id in self._in_flight_file_requests:
-            raise ValueError(f"Duplicate file-selection request id {request_id!r}.")
+            _LOGGER.warning(
+                "Ignoring duplicate file-selection request id %r.",
+                request_id,
+            )
+            return
         self._in_flight_file_requests.add(request_id)
         try:
             selected = _ask_open_filename(
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 320df157c..cf6c7cbc5 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -3,6 +3,7 @@
 
 """WebRTC client window for the v2 runtime."""
 
+import logging
 import threading
 from collections import deque
 from dataclasses import replace
@@ -19,6 +20,8 @@
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class WebRTCClientWindow(IClientWindow):
     """Client window streaming a run to a browser.
@@ -115,12 +118,13 @@ def request_selected_files(
             request_id: Correlation token for the later input event.
             initial_path: Directory hint for the selector; browsers may ignore
                 it. ``None`` uses the current user's home directory.
-
-        Raises:
-            ValueError: ``request_id`` is already waiting for a selector.
         """
         if request_id in self._in_flight_file_requests:
-            raise ValueError(f"Duplicate file-selection request id {request_id!r}.")
+            _LOGGER.warning(
+                "Ignoring duplicate file-selection request id %r.",
+                request_id,
+            )
+            return
         self._in_flight_file_requests.add(request_id)
         self.server.request_selected_files(request_id, initial_path=initial_path)
 
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 2e156b2de..05186d6a1 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -60,12 +60,10 @@ def test_selected_files_event_carries_bytes_and_request_id() -> None:
     assert event.files[0].data == b"png"
 
 
-def test_ui_loop_queues_file_selection_and_rejects_duplicate_ids() -> None:
+def test_ui_loop_ignores_duplicate_file_selection_ids() -> None:
     loop = _ui_loop()
     loop.request_selected_files("open-1", "/tmp")
-
-    with pytest.raises(ValueError, match="Duplicate file-selection request id"):
-        loop.request_selected_files("open-1", "/var")
+    loop.request_selected_files("open-1", "/var")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 812f4875e..3a3c478db 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -148,8 +148,7 @@ async def test_browser_file_upload_reaches_the_input_stream() -> None:
     window.open(_session_desc())
     try:
         window.request_selected_files("open-1", "/tmp")
-        with pytest.raises(ValueError, match="Duplicate file-selection request id"):
-            window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files("open-1", "/tmp")
 
         form = FormData()
         form.add_field("request_id", "open-1")

From 07a23a26a6348f649eaf9dc27ad41d73b2dac76f Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Wed, 30 Sep 2026 15:16:45 -0700
Subject: [PATCH 03/43] Fix CPU ruff isort and leftover review nits

CI's ruff --select I hook reordered numpy after the imgui_ui_demo imports. Fold that in with the stale StepResult stub and the file-selector README line.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/runtime_v2/README.md                | 6 +++---
 flashdreams/test_v2/test_selected_files.py                  | 4 ++--
 .../imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/README.md b/flashdreams/flashdreams/runtime_v2/README.md
index 267129740..ad400a895 100644
--- a/flashdreams/flashdreams/runtime_v2/README.md
+++ b/flashdreams/flashdreams/runtime_v2/README.md
@@ -246,9 +246,9 @@ delegates over the thing that does the work — `Mp4ClientWindow` over
 the output shape, because the session already did.
 
 They differ in what they can do rather than in how they are driven. A session
-chooses its UI independently of the client window. Browser keyboard, mouse and
-focus events arrive on the server's own thread, so it queues them and hands them
-over in batches when the session asks.
+chooses its UI independently of the client window. Browser keyboard, mouse,
+focus, and file-selector events arrive on the server's own thread, so it queues
+them and hands them over in batches when the session asks.
 
 A UI loop may call `request_new_session(session_desc)` during its step with a
 fully resolved replacement description. `run_session` stops and cleans the
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 05186d6a1..a29f879ea 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -25,9 +25,9 @@
 
 
 class _UILoop(IUILoop[None]):
-    def step(self, step_index: int, events: UserInputEvents) -> StepResult | None:
+    def step(self, step_index: int, events: UserInputEvents) -> list[StepResult]:
         del step_index, events
-        return None
+        return []
 
     def reset(self) -> None:
         return
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 9763cda37..b5dbff118 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -9,9 +9,9 @@
 from unittest.mock import Mock
 
 import pytest
-from numpy import uint64
 from imgui_ui_demo.file_picker_app import FilePickerImGuiUILoop, FilePickerState
 from imgui_ui_demo.text_input_app import TextInputImGuiUILoop, TextInputState
+from numpy import uint64
 
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
 from flashdreams.runtime_v2.session_desc import SessionDesc

From 9ee2447f68e6b1fdb3b00bb999f6b1b57aab1b9b Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Wed, 30 Sep 2026 16:40:45 -0700
Subject: [PATCH 04/43] Harden client file selection against picker lifecycle
 and untrusted uploads

Drop SelectedFile.path so apps only see name and bytes. WebRTC admits
uploads for pending ids, completes cancel and failure, and opens the
picker from a viewer click. Native picks off the UI thread with the same
size cap.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |   5 +-
 .../runtime_v2/native_window_client_window.py |  69 ++++++++----
 .../flashdreams/runtime_v2/serving/web/app.js |  59 ++++++++++-
 .../runtime_v2/serving/web/index.html         |  20 ++++
 .../runtime_v2/serving/webrtc_server.py       |  84 +++++++++++----
 .../runtime_v2/user_input_event.py            |  14 +--
 .../runtime_v2/webrtc_client_window.py        |   5 +-
 .../test_native_window_client_window.py       |  25 ++++-
 flashdreams/test_v2/test_selected_files.py    |   2 +-
 .../test_v2/test_webrtc_client_window.py      | 100 ++++++++++++++++++
 integrations_v2/imgui_ui_demo/README.md       |   5 +-
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |   2 +-
 12 files changed, 326 insertions(+), 64 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index f8b8a91de..08b26231a 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -213,8 +213,9 @@ description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. A control that needs a file from the client
 calls `request_selected_files(request_id)`; the window later reports
 `SelectedFilesUserInputEvent` through the same input stream as keyboard and
-mouse. The application reads file bytes from that event and does not open a
-host path.
+mouse. The application reads ``name`` and ``data`` from that event. An empty
+``files`` tuple is a cancelled or unavailable pick (including MP4 and files
+that exceed the window size cap).
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
 [`slangpy_ui_demo` integration](../../../integrations_v2/slangpy_ui_demo/README.md)
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index dd01d56a0..957bee19c 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -28,6 +28,7 @@
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    MAX_SELECTED_FILE_BYTES,
     CloseUserInputEvent,
     GamepadUserInputEvent,
     KeyboardInputState,
@@ -107,6 +108,19 @@ def _ask_open_filename_tkinter(*, initial_dir: str) -> str:
     return str(selected or "")
 
 
+def _selected_file_from_path(path: Path) -> SelectedFile | None:
+    """Load one picked file, or ``None`` when it cannot be used."""
+    try:
+        if path.stat().st_size > MAX_SELECTED_FILE_BYTES:
+            return None
+        data = path.read_bytes()
+    except OSError:
+        return None
+    if len(data) > MAX_SELECTED_FILE_BYTES:
+        return None
+    return SelectedFile(name=path.name, data=data)
+
+
 _PRINTABLE_KEY_NAMES = {
     "space": " ",
     "apostrophe": "'",
@@ -196,6 +210,7 @@ def __init__(
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._in_flight_file_requests: set[str] = set()
+        self._file_request_lock = threading.Lock()
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the native window."""
@@ -237,41 +252,55 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
     def request_selected_files(
         self, request_id: str, initial_path: str | None = None
     ) -> None:
-        """Open a native OS file selector and enqueue the chosen file.
+        """Ask the OS file selector and enqueue the chosen file.
+
+        The desktop dialog runs on a worker thread so the UI loop can keep
+        polling and presenting while the picker is open.
 
         Args:
             request_id: Correlation token for the later input event.
             initial_path: Directory the selector should start in; ``None`` uses
                 the current user's home directory.
         """
-        if request_id in self._in_flight_file_requests:
-            _LOGGER.warning(
-                "Ignoring duplicate file-selection request id %r.",
-                request_id,
-            )
-            return
-        self._in_flight_file_requests.add(request_id)
+        with self._file_request_lock:
+            if request_id in self._in_flight_file_requests:
+                _LOGGER.warning(
+                    "Ignoring duplicate file-selection request id %r.",
+                    request_id,
+                )
+                return
+            self._in_flight_file_requests.add(request_id)
+        worker = threading.Thread(
+            target=self._complete_file_selection,
+            args=(request_id, initial_path or str(Path.home())),
+            name="flashdreams-file-picker",
+            daemon=True,
+        )
+        worker.start()
+
+    def _complete_file_selection(self, request_id: str, initial_dir: str) -> None:
+        """Run the OS picker and enqueue a selected-files event."""
         try:
-            selected = _ask_open_filename(
-                initial_dir=initial_path or str(Path.home()),
-            )
+            selected = _ask_open_filename(initial_dir=initial_dir)
             files: tuple[SelectedFile, ...] = ()
             if selected:
-                path = Path(selected)
-                try:
-                    data = path.read_bytes()
-                except OSError:
-                    data = b""
-                files = (SelectedFile(name=path.name, path=str(path), data=data),)
-            self._put_input(
+                chosen = _selected_file_from_path(Path(selected))
+                if chosen is not None:
+                    files = (chosen,)
+            started_ns = self._session_started_ns
+            elapsed_ns = (
+                0 if started_ns is None else max(0, self._clock_ns() - started_ns)
+            )
+            self._input_events.put(
                 SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
+                    timestamp=uint64(elapsed_ns // 1_000),
                     request_id=request_id,
                     files=files,
                 )
             )
         finally:
-            self._in_flight_file_requests.discard(request_id)
+            with self._file_request_lock:
+                self._in_flight_file_requests.discard(request_id)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Create the GLFW window on the runtime's UI thread.
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 998b403a1..ddfc4acf6 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -7,6 +7,7 @@ const pointerControls = peer.createDataChannel("pointer-controls");
 peer.addTransceiver("video", {direction: "recvonly"});
 const video = document.getElementById("video");
 const status = document.getElementById("status");
+const filePick = document.getElementById("file-pick");
 const pressedKeys = new Map();
 const pressedButtons = new Set();
 const gamepadSnapshots = new Map();
@@ -74,28 +75,76 @@ const applyCursorOptions = options => {
   }
 };
 
+let pendingFileRequestId = null;
+
+const hideFilePicker = () => {
+  pendingFileRequestId = null;
+  if (filePick !== null) {
+    filePick.hidden = true;
+  }
+};
+
+const cancelFileSelection = requestId => {
+  send({type: "file_selector_result", id: requestId, cancelled: true});
+};
+
 const openFileSelector = options => {
   const requestId = options?.id;
+  if (typeof requestId !== "string" || !requestId || filePick === null) {
+    return;
+  }
+  if (pendingFileRequestId !== null && pendingFileRequestId !== requestId) {
+    cancelFileSelection(pendingFileRequestId);
+  }
+  pendingFileRequestId = requestId;
+  filePick.hidden = false;
+};
+
+filePick?.addEventListener("click", () => {
+  const requestId = pendingFileRequestId;
   if (typeof requestId !== "string" || !requestId) {
     return;
   }
   const input = document.createElement("input");
   input.type = "file";
+  let settled = false;
+  const finishCancelled = () => {
+    if (settled || pendingFileRequestId !== requestId) {
+      return;
+    }
+    settled = true;
+    cancelFileSelection(requestId);
+    hideFilePicker();
+  };
   input.addEventListener("change", () => {
     const file = input.files?.[0];
     if (!file) {
-      send({type: "file_selector_result", id: requestId, cancelled: true});
+      finishCancelled();
       return;
     }
     const body = new FormData();
     body.append("request_id", requestId);
     body.append("file", file, file.name);
-    fetch("/api/files", {method: "POST", body}).catch(error => {
-      console.debug("Unable to upload the selected file.", error);
-    });
+    fetch("/api/files", {method: "POST", body})
+      .then(response => {
+        if (settled || pendingFileRequestId !== requestId) {
+          return;
+        }
+        if (!response.ok) {
+          finishCancelled();
+          return;
+        }
+        settled = true;
+        hideFilePicker();
+      })
+      .catch(error => {
+        console.debug("Unable to upload the selected file.", error);
+        finishCancelled();
+      });
   });
+  input.addEventListener("cancel", finishCancelled);
   input.click();
-};
+});
 
 window.addEventListener("focus", updateCursorVisibility);
 window.addEventListener("blur", updateCursorVisibility);
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/index.html b/flashdreams/flashdreams/runtime_v2/serving/web/index.html
index 1b73e1dc8..c5d453f17 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/index.html
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/index.html
@@ -48,11 +48,31 @@
         color: #ff8a8a;
       }
 
+      #file-pick {
+        position: fixed;
+        left: 50%;
+        bottom: 1.5rem;
+        transform: translateX(-50%);
+        z-index: 2;
+        padding: 0.6rem 1.1rem;
+        border: 0;
+        border-radius: 0.4rem;
+        background: #eee;
+        color: #111;
+        font: inherit;
+        cursor: pointer;
+      }
+
+      #file-pick[hidden] {
+        display: none;
+      }
+
     </style>
   </head>
   <body>
     <video id="video" autoplay muted playsinline></video>
     <div id="status" role="status" aria-live="polite">Waiting for the server…</div>
+    <button id="file-pick" type="button" hidden>Choose file</button>
     <script src="/app.js"></script>
   </body>
 </html>
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index fd23e24e4..ceb6eb5d2 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -16,7 +16,6 @@
 from dataclasses import dataclass
 from fractions import Fraction
 from importlib.resources import files
-from pathlib import Path
 from typing import Any, Literal, cast
 
 import numpy as np
@@ -33,6 +32,7 @@
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    MAX_SELECTED_FILE_BYTES,
     CloseUserInputEvent,
     FocusUserInputEvent,
     GamepadUserInputEvent,
@@ -57,9 +57,6 @@
 _INTERACTIVE_FRAME_QUEUE_SIZE = 2
 """Send-ready frames retained while the media sender is temporarily busy."""
 
-_MAX_SELECTED_FILE_BYTES = 32 * 1024 * 1024
-"""Maximum file the browser may upload for one selected-files event."""
-
 _TRANSFER_STREAM_PRIORITY = -1
 """Portable high-priority CUDA stream request for interactive output copies."""
 
@@ -354,6 +351,8 @@ def __init__(
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._queued_file_selectors: list[dict[str, str]] = []
+        self._pending_file_request_ids: set[str] = set()
+        self._file_selector_lock = threading.Lock()
         self._thread = threading.Thread(
             target=self._run_server,
             name="flashdreams-webrtc",
@@ -451,26 +450,54 @@ def request_selected_files(
 
         Args:
             request_id: Correlation token for the later input event.
-            initial_path: Directory hint for the selector; ``None`` uses the
-                current user's home directory.
+            initial_path: Ignored; the browser picker cannot use a host path.
         """
+        del initial_path
         if not isinstance(request_id, str) or not request_id:
             raise ValueError("request_id must be a non-empty string.")
-        if initial_path is None:
-            resolved_initial_path = str(Path.home())
-        elif not isinstance(initial_path, str) or not initial_path:
-            raise ValueError("initial_path must be a non-empty string.")
-        else:
-            resolved_initial_path = initial_path
-        payload = {
-            "type": "file_selector",
-            "id": request_id,
-            "initial_path": resolved_initial_path,
-        }
+        payload = {"type": "file_selector", "id": request_id}
         loop = self._loop
         if loop is None:
             raise RuntimeError("WebRTC server is not running.")
-        loop.call_soon_threadsafe(self._send_file_selector, payload)
+        loop.call_soon_threadsafe(self._arm_file_selector, payload)
+
+    def _arm_file_selector(self, payload: dict[str, str]) -> None:
+        """Record a pending id and send or queue the selector request."""
+        with self._file_selector_lock:
+            self._pending_file_request_ids.add(payload["id"])
+        self._send_file_selector(payload)
+
+    def _take_pending_file_request(self, request_id: str) -> bool:
+        """Return whether ``request_id`` was pending and consume it."""
+        with self._file_selector_lock:
+            if request_id not in self._pending_file_request_ids:
+                return False
+            self._pending_file_request_ids.discard(request_id)
+            return True
+
+    def _invalidate_file_selectors(self) -> None:
+        """Drop queued and pending selector requests without completing them."""
+        with self._file_selector_lock:
+            self._pending_file_request_ids.clear()
+            self._queued_file_selectors.clear()
+
+    def _complete_abandoned_file_selectors(self) -> None:
+        """Complete pending selector requests with empty files."""
+        timestamp_us = self._timestamp_us()
+        with self._file_selector_lock:
+            pending = tuple(self._pending_file_request_ids)
+            self._pending_file_request_ids.clear()
+            self._queued_file_selectors.clear()
+        if timestamp_us is None:
+            return
+        for request_id in pending:
+            self._append_event(
+                SelectedFilesUserInputEvent(
+                    timestamp=timestamp_us,
+                    request_id=request_id,
+                    files=(),
+                )
+            )
 
     def _send_file_selector(self, payload: dict[str, str]) -> None:
         """Send one file-selector request on the WebRTC event-loop thread."""
@@ -549,6 +576,7 @@ def open(self, session_desc: SessionDesc) -> None:
             # Keep timestamps comparable across sessions so events buffered
             # during a handoff retain their real order.
             self._event_origin_ns = time.monotonic_ns()
+        self._invalidate_file_selectors()
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the dimensions used to present subsequent UI frames.
@@ -771,7 +799,7 @@ def _run_server(self) -> None:
     async def _start_server(self) -> None:
         """Create and bind the standalone aiohttp application."""
         self._offer_lock = asyncio.Lock()
-        app = web.Application(client_max_size=_MAX_SELECTED_FILE_BYTES + 1024 * 1024)
+        app = web.Application(client_max_size=MAX_SELECTED_FILE_BYTES + 1024 * 1024)
         app.router.add_get("/", self._serve_browser)
         app.router.add_get("/app.js", self._serve_browser_script)
         app.router.add_get("/healthz", self._health)
@@ -828,10 +856,19 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
         upload = post.get("file")
         if not isinstance(upload, FileField):
             raise web.HTTPBadRequest(reason="File upload requires a file.")
+        if not self._take_pending_file_request(request_id):
+            raise web.HTTPConflict(reason="No pending file selection for this request_id.")
         data = upload.file.read()
-        if len(data) > _MAX_SELECTED_FILE_BYTES:
+        if len(data) > MAX_SELECTED_FILE_BYTES:
+            self._append_event(
+                SelectedFilesUserInputEvent(
+                    timestamp=timestamp_us,
+                    request_id=request_id,
+                    files=(),
+                )
+            )
             raise web.HTTPRequestEntityTooLarge(
-                max_size=_MAX_SELECTED_FILE_BYTES,
+                max_size=MAX_SELECTED_FILE_BYTES,
                 actual_size=len(data),
             )
         name = upload.filename or "upload"
@@ -839,7 +876,7 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
             SelectedFilesUserInputEvent(
                 timestamp=timestamp_us,
                 request_id=request_id,
-                files=(SelectedFile(name=name, path=name, data=data),),
+                files=(SelectedFile(name=name, data=data),),
             )
         )
         return web.Response(status=204)
@@ -1174,6 +1211,8 @@ def _buffer_browser_message(
                     "File selector result must set cancelled true; send files "
                     "with POST /api/files."
                 )
+            if not self._take_pending_file_request(request_id):
+                return
             event = SelectedFilesUserInputEvent(
                 timestamp=timestamp_us,
                 request_id=request_id,
@@ -1208,6 +1247,7 @@ async def _release_peer_connection(
             self._control_channel = None
             self._video_track = None
             self._sent_cursor_options = None
+            self._complete_abandoned_file_selectors()
         else:
             track = detached_video_track
         failures: list[BaseException] = []
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 13674d5c5..e820d1a13 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -9,6 +9,9 @@
 
 from flashdreams.api_v2.user_input_event import UserInputEvent
 
+MAX_SELECTED_FILE_BYTES = 32 * 1024 * 1024
+"""Maximum bytes one selected file may carry into the application."""
+
 
 class KeyboardInputState(Enum):
     """State transition reported by a keyboard input event."""
@@ -235,21 +238,18 @@ class SelectedFile:
     """One file chosen by a client file selector."""
 
     name: str
-    """File name shown to the application, without requiring a host path."""
-
-    path: str
-    """Native host path, or the file name when the client has no path."""
+    """File name shown to the application."""
 
     data: bytes
-    """File contents. Applications should use this rather than opening ``path``."""
+    """File contents."""
 
 
 @dataclass(frozen=True, slots=True, eq=False)
 class SelectedFilesUserInputEvent(UserInputEvent):
     """Files chosen for one :meth:`IClientWindow.request_selected_files` call.
 
-    An empty ``files`` tuple is a cancelled or unavailable selector, including
-    ``--mode mp4`` where no client can pick a file.
+    An empty ``files`` tuple is a cancelled or unavailable selector: dismiss,
+    oversize, unreadable, a dropped WebRTC peer, or ``--mode mp4``.
     """
 
     @classmethod
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index cf6c7cbc5..ce399fdbc 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -116,8 +116,8 @@ def request_selected_files(
 
         Args:
             request_id: Correlation token for the later input event.
-            initial_path: Directory hint for the selector; browsers may ignore
-                it. ``None`` uses the current user's home directory.
+            initial_path: Ignored by the browser picker; kept so the window
+                signature matches :meth:`IClientWindow.request_selected_files`.
         """
         if request_id in self._in_flight_file_requests:
             _LOGGER.warning(
@@ -138,6 +138,7 @@ def open(self, session_desc: SessionDesc) -> None:
         session_event_offset_us = self.server.event_timestamp_us()
         with self._input_lock:
             self._input_events.clear()
+            self._in_flight_file_requests.clear()
             self._session_event_offset_us = session_event_offset_us
 
     def get_user_input_events(self) -> UserInputEvents:
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index c039ed928..d6be159c9 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -7,6 +7,7 @@
 
 import queue
 import threading
+import time
 from collections.abc import Callable, Sequence
 from pathlib import Path
 from types import SimpleNamespace
@@ -39,6 +40,15 @@
 pytestmark = pytest.mark.ci_cpu
 
 
+def _wait_for_input_events(window: NativeWindowClientWindow) -> list[object]:
+    for _ in range(100):
+        events = window.get_user_input_events().get_events()
+        if events:
+            return list(events)
+        time.sleep(0.01)
+    return []
+
+
 def _session_desc() -> SessionDesc:
     return SessionDesc(
         output_layout=VideoTensorLayout.tchw,
@@ -603,7 +613,7 @@ def test_native_window_reports_a_selected_file(
     )
     window.open(_session_desc())
     window.request_selected_files("open-1", str(tmp_path))
-    events = window.get_user_input_events().get_events()
+    events = _wait_for_input_events(window)
     window.close()
 
     assert len(events) == 1
@@ -611,10 +621,21 @@ def test_native_window_reports_a_selected_file(
     assert isinstance(event, SelectedFilesUserInputEvent)
     assert event.request_id == "open-1"
     assert event.files[0].name == "seed.png"
-    assert event.files[0].path == str(chosen)
     assert event.files[0].data == b"png-bytes"
 
 
+def test_selected_file_from_path_skips_unreadable_and_oversize(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    missing = tmp_path / "gone.png"
+    assert native_window_module._selected_file_from_path(missing) is None
+
+    too_big = tmp_path / "big.bin"
+    too_big.write_bytes(b"abcd")
+    monkeypatch.setattr(native_window_module, "MAX_SELECTED_FILE_BYTES", 3)
+    assert native_window_module._selected_file_from_path(too_big) is None
+
+
 def test_ask_open_filename_linux_uses_zenity(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index a29f879ea..b169f34d3 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -52,7 +52,7 @@ def test_selected_files_event_carries_bytes_and_request_id() -> None:
     event = SelectedFilesUserInputEvent(
         timestamp=uint64(1),
         request_id="open-1",
-        files=(SelectedFile(name="seed.png", path="/tmp/seed.png", data=b"png"),),
+        files=(SelectedFile(name="seed.png", data=b"png"),),
     )
 
     assert event.get_type_name() == "selected_files"
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 3a3c478db..17b2841b1 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -149,6 +149,12 @@ async def test_browser_file_upload_reaches_the_input_stream() -> None:
     try:
         window.request_selected_files("open-1", "/tmp")
         window.request_selected_files("open-1", "/tmp")
+        for _ in range(100):
+            if "open-1" in window.server._pending_file_request_ids:
+                break
+            await asyncio.sleep(0.01)
+        else:
+            raise AssertionError("file selection was not armed")
 
         form = FormData()
         form.add_field("request_id", "open-1")
@@ -182,6 +188,96 @@ async def test_browser_file_upload_reaches_the_input_stream() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_unsolicited_file_upload_is_rejected() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        form = FormData()
+        form.add_field("request_id", "open-1")
+        form.add_field(
+            "file",
+            b"hello",
+            filename="hello.txt",
+            content_type="text/plain",
+        )
+        async with ClientSession() as client:
+            async with client.post(
+                f"{window.server.url}api/files", data=form
+            ) as response:
+                assert response.status == 409
+        assert window.get_user_input_events().get_events() == []
+    finally:
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_browser_file_selector_omits_host_path() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, channel, _ = await _connect_browser(window)
+        messages: list[dict[str, object]] = []
+
+        @channel.on("message")
+        def on_message(message: object) -> None:
+            if isinstance(message, str):
+                messages.append(json.loads(message))
+
+        window.request_selected_files("open-1", "/home/secret")
+        for _ in range(100):
+            if any(item.get("type") == "file_selector" for item in messages):
+                break
+            await asyncio.sleep(0.01)
+        payload = next(
+            item for item in messages if item.get("type") == "file_selector"
+        )
+        assert payload == {"type": "file_selector", "id": "open-1"}
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_session_handoff_clears_pending_file_selection() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", "/tmp")
+        for _ in range(100):
+            if "open-1" in window.server._pending_file_request_ids:
+                break
+            await asyncio.sleep(0.01)
+        else:
+            raise AssertionError("file selection was not armed")
+        window.open(_session_desc())
+        assert "open-1" not in window.server._pending_file_request_ids
+        window.request_selected_files("open-1", "/tmp")
+        for _ in range(100):
+            if "open-1" in window.server._pending_file_request_ids:
+                break
+            await asyncio.sleep(0.01)
+        else:
+            raise AssertionError("file selection was not re-armed")
+        form = FormData()
+        form.add_field("request_id", "open-1")
+        form.add_field(
+            "file",
+            b"hello",
+            filename="hello.txt",
+            content_type="text/plain",
+        )
+        async with ClientSession() as client:
+            async with client.post(
+                f"{window.server.url}api/files", data=form
+            ) as response:
+                assert response.status == 204
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_window_buffers_browser_events_until_drained() -> None:
     window = WebRTCClientWindow()
@@ -220,6 +316,7 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert 'id="reset"' not in browser_page
                 assert '<video id="video" autoplay muted playsinline>' in browser_page
                 assert 'id="status"' in browser_page
+                assert 'id="file-pick"' in browser_page
                 assert '<script src="/app.js"></script>' in browser_page
             async with client.get(f"{window.server.url}app.js") as response:
                 browser_script = await response.text()
@@ -259,6 +356,9 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert "openFileSelector" in browser_script
                 assert 'type === "file_selector"' in browser_script
                 assert 'fetch("/api/files"' in browser_script
+                assert 'addEventListener("cancel"' in browser_script
+                assert "Choose file" in browser_page
+                assert "response.ok" in browser_script
 
         window.request_hide_cursor(True)
         window.open(_session_desc())
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index 50eaa79a9..2142a9f35 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -27,8 +27,9 @@ uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 ```
 
 Run the file-picker application. Native Linux needs `zenity` or `kdialog`
-(the desktop portal picker). Windows and macOS use Tk. WebRTC uses the
-browser picker; uploads larger than 32 MiB are rejected.
+(the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
+**Choose file** control in the viewer (the picker must open from a browser
+click). Picks larger than 32 MiB are rejected in every mode.
 ```bash
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode native-window
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode webrtc \
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index b5dbff118..9d6ed5df3 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -113,7 +113,7 @@ def test_selected_files_event_updates_file_picker_status() -> None:
                 SelectedFilesUserInputEvent(
                     timestamp=uint64(0),
                     request_id="open-1",
-                    files=(SelectedFile(name="seed.png", path="seed.png", data=b"xx"),),
+                    files=(SelectedFile(name="seed.png", data=b"xx"),),
                 )
             ]
         ),

From f99b69a6107eadb46e68cfac50cbe598c5ef7c40 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 1 Oct 2026 09:35:09 -0700
Subject: [PATCH 05/43] Apply ruff format to the file-selection WebRTC changes

CI's ruff-format hook wrapped the pending-upload HTTPConflict and
collapsed a one-line next() in the host-path omission test.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py | 4 +++-
 flashdreams/test_v2/test_webrtc_client_window.py            | 4 +---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index ceb6eb5d2..02d4e70ce 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -857,7 +857,9 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
         if not isinstance(upload, FileField):
             raise web.HTTPBadRequest(reason="File upload requires a file.")
         if not self._take_pending_file_request(request_id):
-            raise web.HTTPConflict(reason="No pending file selection for this request_id.")
+            raise web.HTTPConflict(
+                reason="No pending file selection for this request_id."
+            )
         data = upload.file.read()
         if len(data) > MAX_SELECTED_FILE_BYTES:
             self._append_event(
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 17b2841b1..54104613b 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -230,9 +230,7 @@ def on_message(message: object) -> None:
             if any(item.get("type") == "file_selector" for item in messages):
                 break
             await asyncio.sleep(0.01)
-        payload = next(
-            item for item in messages if item.get("type") == "file_selector"
-        )
+        payload = next(item for item in messages if item.get("type") == "file_selector")
         assert payload == {"type": "file_selector", "id": "open-1"}
     finally:
         if peer is not None:

From d0c5262515d5ee6639029cb23505b96487182799 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 1 Oct 2026 14:02:51 -0700
Subject: [PATCH 06/43] Let apps declare file-picker type and size; windows
 enforce the ceiling Native and WebRTC both clamp max_bytes to 32 MiB and
 honor accept suffixes so a viewer cannot raise the cap. The UI loop only
 queues policy.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  13 +-
 .../flashdreams/api_v2/client_window.py       |  13 +-
 flashdreams/flashdreams/api_v2/loop.py        |  36 +++-
 .../runtime_v2/mp4_client_window.py           |  12 +-
 .../runtime_v2/native_window_client_window.py |  86 +++++++--
 .../flashdreams/runtime_v2/serving/web/app.js |  51 +++--
 .../runtime_v2/serving/webrtc_server.py       | 137 ++++++++++---
 .../flashdreams/runtime_v2/session_runner.py  |   7 +-
 .../runtime_v2/user_input_event.py            |  71 ++++++-
 .../runtime_v2/webrtc_client_window.py        |  17 +-
 .../test_native_window_client_window.py       |  38 +++-
 flashdreams/test_v2/test_selected_files.py    |  40 ++++
 flashdreams/test_v2/test_session_runner.py    |  22 ++-
 .../test_v2/test_webrtc_client_window.py      | 181 +++++++++++++-----
 integrations_v2/imgui_ui_demo/README.md       |   3 +-
 .../imgui_ui_demo/file_picker_app.py          |  13 +-
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |   3 +
 17 files changed, 604 insertions(+), 139 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 73c6df7a1..fdc618786 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -224,11 +224,14 @@ UI control that needs a fresh application session calls
 `request_new_session(session_desc)` with a fully resolved replacement
 description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. A control that needs a file from the client
-calls `request_selected_files(request_id)`; the window later reports
-`SelectedFilesUserInputEvent` through the same input stream as keyboard and
-mouse. The application reads ``name`` and ``data`` from that event. An empty
-``files`` tuple is a cancelled or unavailable pick (including MP4 and files
-that exceed the window size cap).
+calls `request_selected_files(request_id, accept=..., max_bytes=...)`; the
+window later reports `SelectedFilesUserInputEvent` through the same input
+stream as keyboard and mouse. The application reads ``name`` and ``data`` from
+that event. ``accept`` (filename suffixes such as ``.png``) and ``max_bytes``
+are the application's policy; windows enforce them and clamp size to 32 MiB
+so a client cannot raise the cap. An empty ``files`` tuple is a cancelled or
+unavailable pick (including MP4, disallowed type, and files that exceed the
+budget).
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
 [`slangpy_ui_demo` integration](../../../integrations_v2/slangpy_ui_demo/README.md)
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 936f4a7cf..6e68f02d1 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -4,6 +4,7 @@
 """Client window abstract interface."""
 
 from abc import ABC
+from collections.abc import Sequence
 
 from .input_source import InputSource
 from .output_sink import OutputSink
@@ -49,16 +50,24 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     # Optional to implement
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Ask this client to pick files and report them as input events.
 
         The chosen files arrive later through
-        :meth:`InputSource.get_user_input_events`.
+        :meth:`InputSource.get_user_input_events`. Windows enforce ``accept``
+        and ``max_bytes`` and clamp the size to the 32 MiB ceiling.
 
         Args:
             request_id: Correlation token for the later input event.
             initial_path: Directory the selector should start in; ``None`` lets
                 the window choose a default.
+            accept: Filename suffixes such as ``.png``. Empty allows any type.
+            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
         """
         pass
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 8c803ae35..d9d6ea9a5 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -10,7 +10,7 @@
 import threading
 import time
 from abc import ABC, abstractmethod
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
@@ -24,6 +24,7 @@
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
     UserInputEvent,
+    normalize_selected_file_accept,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
@@ -86,6 +87,12 @@ class FileSelectionRequest:
     initial_path: str
     """Directory the selector should start in."""
 
+    accept: tuple[str, ...] = ()
+    """Filename suffixes the client may choose, empty for any type."""
+
+    max_bytes: int | None = None
+    """Requested size budget in bytes, or ``None`` for the window ceiling."""
+
 
 @dataclass(slots=True)
 class UILoopRequests:
@@ -538,7 +545,12 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     @final
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Ask the client window to open a file selector.
 
@@ -547,14 +559,22 @@ def request_selected_files(
         A second call with the same ``request_id`` while the first is still
         queued is ignored so the original picker can still complete.
 
+        ``accept`` and ``max_bytes`` are the application's policy. Windows
+        enforce them and clamp ``max_bytes`` to the 32 MiB ceiling so a client
+        cannot raise the cap.
+
         Args:
             request_id: Correlation token for the later input event.
             initial_path: Directory the selector should start in; ``None`` uses
                 the current user's home directory.
+            accept: Filename suffixes such as ``.png``. Empty allows any type.
+            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
 
         Raises:
-            TypeError: ``request_id`` or ``initial_path`` is not a string.
-            ValueError: ``request_id`` is empty or ``initial_path`` is empty.
+            TypeError: ``request_id`` or ``initial_path`` is not a string, or
+                ``accept`` / ``max_bytes`` has the wrong type.
+            ValueError: ``request_id`` is empty, ``initial_path`` is empty, or
+                ``accept`` / ``max_bytes`` is invalid.
         """
         if not isinstance(request_id, str):
             raise TypeError("request_id must be a string.")
@@ -568,6 +588,12 @@ def request_selected_files(
             if not initial_path:
                 raise ValueError("initial_path must be a non-empty string.")
             resolved_initial_path = initial_path
+        suffixes = normalize_selected_file_accept(accept)
+        if max_bytes is not None:
+            if isinstance(max_bytes, bool) or not isinstance(max_bytes, int):
+                raise TypeError("max_bytes must be an integer.")
+            if max_bytes <= 0:
+                raise ValueError("max_bytes must be > 0.")
         requests = self.get_or_create_ui_loop_requests()
         if any(
             selection.request_id == request_id for selection in requests.file_selections
@@ -581,6 +607,8 @@ def request_selected_files(
             FileSelectionRequest(
                 request_id=request_id,
                 initial_path=resolved_initial_path,
+                accept=suffixes,
+                max_bytes=max_bytes,
             )
         )
 
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index 8784d02f5..23cc31598 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -3,6 +3,7 @@
 
 """Client window that writes an MP4 file."""
 
+from collections.abc import Sequence
 from pathlib import Path
 
 from numpy import uint64
@@ -50,15 +51,22 @@ def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents(events)
 
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Complete a file-selector request with no files.
 
         Args:
             request_id: Correlation token from the UI loop.
             initial_path: Ignored; an MP4 has no selector.
+            accept: Ignored; an MP4 has no selector.
+            max_bytes: Ignored; an MP4 has no selector.
         """
-        del initial_path
+        del initial_path, accept, max_bytes
         self._pending_events.append(
             SelectedFilesUserInputEvent(
                 timestamp=uint64(0),
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 957bee19c..98fedb9cf 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -13,7 +13,7 @@
 import threading
 import time
 from collections import deque
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from dataclasses import replace
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
@@ -36,6 +36,9 @@
     MouseUserInputEvent,
     SelectedFile,
     SelectedFilesUserInputEvent,
+    clamp_selected_file_max_bytes,
+    normalize_selected_file_accept,
+    selected_file_suffix_allowed,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -46,14 +49,19 @@
 _LOGGER = logging.getLogger(__name__)
 
 
-def _ask_open_filename(*, initial_dir: str) -> str:
+def _ask_open_filename(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     """Return a path from the OS file picker, or ``""`` when cancelled."""
     if sys.platform.startswith("linux"):
-        return _ask_open_filename_linux(initial_dir=initial_dir)
-    return _ask_open_filename_tkinter(initial_dir=initial_dir)
+        return _ask_open_filename_linux(initial_dir=initial_dir, accept=accept)
+    return _ask_open_filename_tkinter(initial_dir=initial_dir, accept=accept)
 
 
-def _ask_open_filename_linux(*, initial_dir: str) -> str:
+def _accept_filter_patterns(accept: tuple[str, ...]) -> str:
+    """Return glob patterns for ``accept`` suffixes, such as ``*.png *.jpg``."""
+    return " ".join(f"*{suffix}" for suffix in accept)
+
+
+def _ask_open_filename_linux(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     """Open the desktop file picker via ``zenity`` or ``kdialog``.
 
     ``zenity --file-selection`` uses ``GtkFileChooserNative``, which is the
@@ -61,6 +69,7 @@ def _ask_open_filename_linux(*, initial_dir: str) -> str:
     GLFW window does not host GTK.
     """
     directory = str(Path(initial_dir))
+    patterns = _accept_filter_patterns(accept)
     zenity = shutil.which("zenity")
     if zenity is not None:
         argv = [
@@ -69,6 +78,8 @@ def _ask_open_filename_linux(*, initial_dir: str) -> str:
             f"--filename={directory}/",
             "--title=Select a file",
         ]
+        if patterns:
+            argv.append(f"--file-filter=Accepted | {patterns}")
     else:
         kdialog = shutil.which("kdialog")
         if kdialog is None:
@@ -76,6 +87,8 @@ def _ask_open_filename_linux(*, initial_dir: str) -> str:
                 "Native file picker needs a desktop chooser (zenity or kdialog)."
             )
         argv = [kdialog, "--getopenfilename", directory]
+        if patterns:
+            argv.append(f"Accepted ({patterns})")
     completed = subprocess.run(
         argv,
         check=False,
@@ -87,7 +100,9 @@ def _ask_open_filename_linux(*, initial_dir: str) -> str:
     return completed.stdout.strip()
 
 
-def _ask_open_filename_tkinter(*, initial_dir: str) -> str:
+def _ask_open_filename_tkinter(
+    *, initial_dir: str, accept: tuple[str, ...] = ()
+) -> str:
     """Open the Tk file dialog (native Explorer / macOS panel)."""
     import tkinter as tk
     from tkinter import filedialog
@@ -99,24 +114,35 @@ def _ask_open_filename_tkinter(*, initial_dir: str) -> str:
     except tk.TclError:
         pass
     try:
-        selected = filedialog.askopenfilename(
-            initialdir=initial_dir,
-            title="Select a file",
-        )
+        kwargs: dict[str, Any] = {
+            "initialdir": initial_dir,
+            "title": "Select a file",
+        }
+        if accept:
+            kwargs["filetypes"] = [("Accepted", _accept_filter_patterns(accept))]
+        selected = filedialog.askopenfilename(**kwargs)
     finally:
         root.destroy()
     return str(selected or "")
 
 
-def _selected_file_from_path(path: Path) -> SelectedFile | None:
+def _selected_file_from_path(
+    path: Path,
+    *,
+    accept: tuple[str, ...] = (),
+    max_bytes: int | None = None,
+) -> SelectedFile | None:
     """Load one picked file, or ``None`` when it cannot be used."""
+    budget = MAX_SELECTED_FILE_BYTES if max_bytes is None else max_bytes
+    if not selected_file_suffix_allowed(path.name, accept):
+        return None
     try:
-        if path.stat().st_size > MAX_SELECTED_FILE_BYTES:
+        if path.stat().st_size > budget:
             return None
         data = path.read_bytes()
     except OSError:
         return None
-    if len(data) > MAX_SELECTED_FILE_BYTES:
+    if len(data) > budget:
         return None
     return SelectedFile(name=path.name, data=data)
 
@@ -250,7 +276,12 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         self._window_size = presenter.resize(*new_window_size)
 
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Ask the OS file selector and enqueue the chosen file.
 
@@ -261,7 +292,11 @@ def request_selected_files(
             request_id: Correlation token for the later input event.
             initial_path: Directory the selector should start in; ``None`` uses
                 the current user's home directory.
+            accept: Filename suffixes such as ``.png``. Empty allows any type.
+            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
         """
+        suffixes = normalize_selected_file_accept(accept)
+        budget = clamp_selected_file_max_bytes(max_bytes)
         with self._file_request_lock:
             if request_id in self._in_flight_file_requests:
                 _LOGGER.warning(
@@ -272,19 +307,34 @@ def request_selected_files(
             self._in_flight_file_requests.add(request_id)
         worker = threading.Thread(
             target=self._complete_file_selection,
-            args=(request_id, initial_path or str(Path.home())),
+            args=(
+                request_id,
+                initial_path or str(Path.home()),
+                suffixes,
+                budget,
+            ),
             name="flashdreams-file-picker",
             daemon=True,
         )
         worker.start()
 
-    def _complete_file_selection(self, request_id: str, initial_dir: str) -> None:
+    def _complete_file_selection(
+        self,
+        request_id: str,
+        initial_dir: str,
+        accept: tuple[str, ...],
+        max_bytes: int,
+    ) -> None:
         """Run the OS picker and enqueue a selected-files event."""
         try:
-            selected = _ask_open_filename(initial_dir=initial_dir)
+            selected = _ask_open_filename(initial_dir=initial_dir, accept=accept)
             files: tuple[SelectedFile, ...] = ()
             if selected:
-                chosen = _selected_file_from_path(Path(selected))
+                chosen = _selected_file_from_path(
+                    Path(selected),
+                    accept=accept,
+                    max_bytes=max_bytes,
+                )
                 if chosen is not None:
                     files = (chosen,)
             started_ns = self._session_started_ns
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index ddfc4acf6..389b824b7 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -75,10 +75,10 @@ const applyCursorOptions = options => {
   }
 };
 
-let pendingFileRequestId = null;
+let pendingFileRequest = null;
 
 const hideFilePicker = () => {
-  pendingFileRequestId = null;
+  pendingFileRequest = null;
   if (filePick !== null) {
     filePick.hidden = true;
   }
@@ -88,28 +88,48 @@ const cancelFileSelection = requestId => {
   send({type: "file_selector_result", id: requestId, cancelled: true});
 };
 
+const fileNameMatchesAccept = (name, accept) => {
+  if (!Array.isArray(accept) || accept.length === 0) {
+    return true;
+  }
+  const lower = name.toLowerCase();
+  return accept.some(
+    suffix => typeof suffix === "string" && lower.endsWith(suffix.toLowerCase()),
+  );
+};
+
 const openFileSelector = options => {
   const requestId = options?.id;
   if (typeof requestId !== "string" || !requestId || filePick === null) {
     return;
   }
-  if (pendingFileRequestId !== null && pendingFileRequestId !== requestId) {
-    cancelFileSelection(pendingFileRequestId);
+  if (pendingFileRequest !== null && pendingFileRequest.id !== requestId) {
+    cancelFileSelection(pendingFileRequest.id);
   }
-  pendingFileRequestId = requestId;
+  const accept = Array.isArray(options.accept) ? options.accept : [];
+  const maxBytes = Number(options.max_bytes);
+  pendingFileRequest = {
+    id: requestId,
+    accept,
+    maxBytes: Number.isFinite(maxBytes) ? maxBytes : 0,
+  };
   filePick.hidden = false;
 };
 
 filePick?.addEventListener("click", () => {
-  const requestId = pendingFileRequestId;
-  if (typeof requestId !== "string" || !requestId) {
+  const pending = pendingFileRequest;
+  const requestId = pending?.id;
+  if (typeof requestId !== "string" || !requestId || pending === null) {
     return;
   }
   const input = document.createElement("input");
   input.type = "file";
+  if (pending.accept.length > 0) {
+    input.accept = pending.accept.join(",");
+  }
   let settled = false;
   const finishCancelled = () => {
-    if (settled || pendingFileRequestId !== requestId) {
+    if (settled || pendingFileRequest === null || pendingFileRequest.id !== requestId) {
       return;
     }
     settled = true;
@@ -122,12 +142,21 @@ filePick?.addEventListener("click", () => {
       finishCancelled();
       return;
     }
+    if (
+      !fileNameMatchesAccept(file.name || "", pending.accept)
+      || file.size > pending.maxBytes
+    ) {
+      finishCancelled();
+      return;
+    }
     const body = new FormData();
-    body.append("request_id", requestId);
     body.append("file", file, file.name);
-    fetch("/api/files", {method: "POST", body})
+    fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`, {
+      method: "POST",
+      body,
+    })
       .then(response => {
-        if (settled || pendingFileRequestId !== requestId) {
+        if (settled || pendingFileRequest === null || pendingFileRequest.id !== requestId) {
           return;
         }
         if (!response.ok) {
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 02d4e70ce..61f22413f 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -12,7 +12,7 @@
 import threading
 import time
 from collections import deque
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from fractions import Fraction
 from importlib.resources import files
@@ -47,6 +47,9 @@
     TouchUserInputEvent,
     UserInputEvent,
     XRControllerUserInputEvent,
+    clamp_selected_file_max_bytes,
+    normalize_selected_file_accept,
+    selected_file_suffix_allowed,
 )
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
 
@@ -298,6 +301,21 @@ async def _next_queued_frame(self) -> _QueuedRGBFrame:
             await self._frame_available.wait()
 
 
+_FILE_UPLOAD_HEADER_SLACK_BYTES = 4 * 1024
+"""Multipart wrapper bytes allowed on top of a selected-file size budget."""
+
+
+@dataclass(frozen=True, slots=True)
+class _PendingFileSelection:
+    """Accept suffixes and size budget for one armed file-selector request."""
+
+    accept: tuple[str, ...]
+    """Filename suffixes the client may upload, empty for any type."""
+
+    max_bytes: int
+    """Maximum file bytes, already clamped to the window ceiling."""
+
+
 class WebRTCServer:
     """Own the HTTP, signaling, input buffering, and media transport."""
 
@@ -350,8 +368,8 @@ def __init__(
         self._client_connected = False
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._queued_file_selectors: list[dict[str, str]] = []
-        self._pending_file_request_ids: set[str] = set()
+        self._queued_file_selectors: list[dict[str, Any]] = []
+        self._pending_file_requests: dict[str, _PendingFileSelection] = {}
         self._file_selector_lock = threading.Lock()
         self._thread = threading.Thread(
             target=self._run_server,
@@ -444,49 +462,72 @@ def _send_cursor_options(self) -> None:
         self._sent_cursor_options = cursor_options
 
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Ask the connected browser to open a file selector.
 
         Args:
             request_id: Correlation token for the later input event.
             initial_path: Ignored; the browser picker cannot use a host path.
+            accept: Filename suffixes such as ``.png``. Empty allows any type.
+            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
         """
         del initial_path
         if not isinstance(request_id, str) or not request_id:
             raise ValueError("request_id must be a non-empty string.")
-        payload = {"type": "file_selector", "id": request_id}
+        suffixes = normalize_selected_file_accept(accept)
+        budget = clamp_selected_file_max_bytes(max_bytes)
+        payload: dict[str, Any] = {
+            "type": "file_selector",
+            "id": request_id,
+            "accept": list(suffixes),
+            "max_bytes": budget,
+        }
         loop = self._loop
         if loop is None:
             raise RuntimeError("WebRTC server is not running.")
         loop.call_soon_threadsafe(self._arm_file_selector, payload)
 
-    def _arm_file_selector(self, payload: dict[str, str]) -> None:
-        """Record a pending id and send or queue the selector request."""
+    def _arm_file_selector(self, payload: dict[str, Any]) -> None:
+        """Record pending policy and send or queue the selector request."""
+        request_id = payload["id"]
+        if not isinstance(request_id, str):
+            raise TypeError("file selector id must be a string.")
+        accept = payload["accept"]
+        max_bytes = payload["max_bytes"]
+        if not isinstance(accept, list) or not isinstance(max_bytes, int):
+            raise TypeError("file selector payload must include accept and max_bytes.")
         with self._file_selector_lock:
-            self._pending_file_request_ids.add(payload["id"])
+            self._pending_file_requests[request_id] = _PendingFileSelection(
+                accept=tuple(accept),
+                max_bytes=max_bytes,
+            )
         self._send_file_selector(payload)
 
-    def _take_pending_file_request(self, request_id: str) -> bool:
-        """Return whether ``request_id`` was pending and consume it."""
+    def _take_pending_file_request(
+        self, request_id: str
+    ) -> _PendingFileSelection | None:
+        """Return and consume the policy for ``request_id``, if it was pending."""
         with self._file_selector_lock:
-            if request_id not in self._pending_file_request_ids:
-                return False
-            self._pending_file_request_ids.discard(request_id)
-            return True
+            return self._pending_file_requests.pop(request_id, None)
 
     def _invalidate_file_selectors(self) -> None:
         """Drop queued and pending selector requests without completing them."""
         with self._file_selector_lock:
-            self._pending_file_request_ids.clear()
+            self._pending_file_requests.clear()
             self._queued_file_selectors.clear()
 
     def _complete_abandoned_file_selectors(self) -> None:
         """Complete pending selector requests with empty files."""
         timestamp_us = self._timestamp_us()
         with self._file_selector_lock:
-            pending = tuple(self._pending_file_request_ids)
-            self._pending_file_request_ids.clear()
+            pending = tuple(self._pending_file_requests)
+            self._pending_file_requests.clear()
             self._queued_file_selectors.clear()
         if timestamp_us is None:
             return
@@ -499,7 +540,7 @@ def _complete_abandoned_file_selectors(self) -> None:
                 )
             )
 
-    def _send_file_selector(self, payload: dict[str, str]) -> None:
+    def _send_file_selector(self, payload: dict[str, Any]) -> None:
         """Send one file-selector request on the WebRTC event-loop thread."""
         channel = self._control_channel
         if channel is None or channel.readyState != "open":
@@ -849,19 +890,19 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
         timestamp_us = self._timestamp_us()
         if timestamp_us is None:
             raise web.HTTPConflict(reason="WebRTC server is not open.")
-        post = await request.post()
-        request_id = post.get("request_id")
+        request_id = request.query.get("request_id")
         if not isinstance(request_id, str) or not request_id:
             raise web.HTTPBadRequest(reason="File upload requires request_id.")
-        upload = post.get("file")
-        if not isinstance(upload, FileField):
-            raise web.HTTPBadRequest(reason="File upload requires a file.")
-        if not self._take_pending_file_request(request_id):
+        policy = self._take_pending_file_request(request_id)
+        if policy is None:
             raise web.HTTPConflict(
                 reason="No pending file selection for this request_id."
             )
-        data = upload.file.read()
-        if len(data) > MAX_SELECTED_FILE_BYTES:
+        content_length = request.content_length
+        if (
+            content_length is not None
+            and content_length > policy.max_bytes + _FILE_UPLOAD_HEADER_SLACK_BYTES
+        ):
             self._append_event(
                 SelectedFilesUserInputEvent(
                     timestamp=timestamp_us,
@@ -870,10 +911,48 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
                 )
             )
             raise web.HTTPRequestEntityTooLarge(
-                max_size=MAX_SELECTED_FILE_BYTES,
-                actual_size=len(data),
+                max_size=policy.max_bytes,
+                actual_size=content_length,
             )
+        try:
+            post = await request.post()
+        except web.HTTPRequestEntityTooLarge:
+            self._append_event(
+                SelectedFilesUserInputEvent(
+                    timestamp=timestamp_us,
+                    request_id=request_id,
+                    files=(),
+                )
+            )
+            raise
+        upload = post.get("file")
+        if not isinstance(upload, FileField):
+            self._append_event(
+                SelectedFilesUserInputEvent(
+                    timestamp=timestamp_us,
+                    request_id=request_id,
+                    files=(),
+                )
+            )
+            raise web.HTTPBadRequest(reason="File upload requires a file.")
+        data = upload.file.read()
         name = upload.filename or "upload"
+        if len(data) > policy.max_bytes or not selected_file_suffix_allowed(
+            name, policy.accept
+        ):
+            self._append_event(
+                SelectedFilesUserInputEvent(
+                    timestamp=timestamp_us,
+                    request_id=request_id,
+                    files=(),
+                )
+            )
+            if len(data) > policy.max_bytes:
+                raise web.HTTPRequestEntityTooLarge(
+                    max_size=policy.max_bytes,
+                    actual_size=len(data),
+                )
+            return web.Response(status=204)
         self._append_event(
             SelectedFilesUserInputEvent(
                 timestamp=timestamp_us,
@@ -1213,7 +1292,7 @@ def _buffer_browser_message(
                     "File selector result must set cancelled true; send files "
                     "with POST /api/files."
                 )
-            if not self._take_pending_file_request(request_id):
+            if self._take_pending_file_request(request_id) is None:
                 return
             event = SelectedFilesUserInputEvent(
                 timestamp=timestamp_us,
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 439ec23a7..ff6f7013a 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -403,7 +403,12 @@ def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> No
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
     for selection in request.file_selections:
-        window.request_selected_files(selection.request_id, selection.initial_path)
+        window.request_selected_files(
+            selection.request_id,
+            selection.initial_path,
+            accept=selection.accept,
+            max_bytes=selection.max_bytes,
+        )
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index e820d1a13..52bde919f 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -3,6 +3,7 @@
 
 """Concrete user input events for supported input modalities."""
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
 from typing import Literal
@@ -10,7 +11,72 @@
 from flashdreams.api_v2.user_input_event import UserInputEvent
 
 MAX_SELECTED_FILE_BYTES = 32 * 1024 * 1024
-"""Maximum bytes one selected file may carry into the application."""
+"""Hard ceiling for one selected file. Windows clamp requested budgets to this."""
+
+
+def clamp_selected_file_max_bytes(max_bytes: int | None) -> int:
+    """Return a file-size budget that cannot exceed ``MAX_SELECTED_FILE_BYTES``.
+
+    Args:
+        max_bytes: Requested budget in bytes, or ``None`` for the ceiling.
+
+    Returns:
+        The requested budget when it is below the ceiling, otherwise the ceiling.
+
+    Raises:
+        TypeError: ``max_bytes`` is not ``None`` or an integer.
+        ValueError: ``max_bytes`` is not positive.
+    """
+    if max_bytes is None:
+        return MAX_SELECTED_FILE_BYTES
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int):
+        raise TypeError("max_bytes must be an integer.")
+    if max_bytes <= 0:
+        raise ValueError("max_bytes must be > 0.")
+    return min(max_bytes, MAX_SELECTED_FILE_BYTES)
+
+
+def normalize_selected_file_accept(accept: Sequence[str] = ()) -> tuple[str, ...]:
+    """Return accepted filename suffixes such as ``.png``.
+
+    Args:
+        accept: Suffixes the client may choose. Empty means any type.
+
+    Returns:
+        The suffixes as a tuple, unchanged except for the sequence type.
+
+    Raises:
+        TypeError: ``accept`` is not a sequence of strings.
+        ValueError: A suffix is missing the leading ``.`` or contains a path.
+    """
+    if isinstance(accept, str) or not isinstance(accept, Sequence):
+        raise TypeError("accept must be a sequence of suffixes.")
+    suffixes: list[str] = []
+    for suffix in accept:
+        if not isinstance(suffix, str):
+            raise TypeError("accept suffixes must be strings.")
+        if (
+            not suffix.startswith(".")
+            or suffix == "."
+            or "/" in suffix
+            or "\\" in suffix
+        ):
+            raise ValueError(
+                "accept suffixes must look like ``.png`` and cannot contain a path."
+            )
+        suffixes.append(suffix)
+    return tuple(suffixes)
+
+
+def selected_file_suffix_allowed(name: str, accept: tuple[str, ...]) -> bool:
+    """Return whether ``name`` matches ``accept``.
+
+    Empty ``accept`` allows any name. Comparison is case-insensitive.
+    """
+    if not accept:
+        return True
+    lower = name.lower()
+    return any(lower.endswith(suffix.lower()) for suffix in accept)
 
 
 class KeyboardInputState(Enum):
@@ -249,7 +315,8 @@ class SelectedFilesUserInputEvent(UserInputEvent):
     """Files chosen for one :meth:`IClientWindow.request_selected_files` call.
 
     An empty ``files`` tuple is a cancelled or unavailable selector: dismiss,
-    oversize, unreadable, a dropped WebRTC peer, or ``--mode mp4``.
+    oversize, disallowed type, unreadable, a dropped WebRTC peer, or
+    ``--mode mp4``.
     """
 
     @classmethod
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index ce399fdbc..94da59585 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -6,6 +6,7 @@
 import logging
 import threading
 from collections import deque
+from collections.abc import Sequence
 from dataclasses import replace
 
 from numpy import uint64
@@ -110,7 +111,12 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         self.server.request_new_window_size(new_window_size)
 
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Ask the connected browser to open a file selector.
 
@@ -118,6 +124,8 @@ def request_selected_files(
             request_id: Correlation token for the later input event.
             initial_path: Ignored by the browser picker; kept so the window
                 signature matches :meth:`IClientWindow.request_selected_files`.
+            accept: Filename suffixes forwarded to the browser picker.
+            max_bytes: Size budget forwarded to the browser and upload handler.
         """
         if request_id in self._in_flight_file_requests:
             _LOGGER.warning(
@@ -126,7 +134,12 @@ def request_selected_files(
             )
             return
         self._in_flight_file_requests.add(request_id)
-        self.server.request_selected_files(request_id, initial_path=initial_path)
+        self.server.request_selected_files(
+            request_id,
+            initial_path=initial_path,
+            accept=accept,
+            max_bytes=max_bytes,
+        )
 
     def open(self, session_desc: SessionDesc) -> None:
         """Implement ``OutputSink.open`` by configuring WebRTC output.
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index d6be159c9..32b0a8476 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -605,7 +605,7 @@ def test_native_window_reports_a_selected_file(
     monkeypatch.setattr(
         native_window_module,
         "_ask_open_filename",
-        lambda *, initial_dir: str(chosen),
+        lambda *, initial_dir, accept=(): str(chosen),
     )
     presenter = _Presenter()
     window = NativeWindowClientWindow(
@@ -625,15 +625,21 @@ def test_native_window_reports_a_selected_file(
 
 
 def test_selected_file_from_path_skips_unreadable_and_oversize(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    tmp_path: Path,
 ) -> None:
     missing = tmp_path / "gone.png"
     assert native_window_module._selected_file_from_path(missing) is None
 
     too_big = tmp_path / "big.bin"
     too_big.write_bytes(b"abcd")
-    monkeypatch.setattr(native_window_module, "MAX_SELECTED_FILE_BYTES", 3)
-    assert native_window_module._selected_file_from_path(too_big) is None
+    assert native_window_module._selected_file_from_path(too_big, max_bytes=3) is None
+
+    wrong_type = tmp_path / "notes.txt"
+    wrong_type.write_bytes(b"hi")
+    assert (
+        native_window_module._selected_file_from_path(wrong_type, accept=(".png",))
+        is None
+    )
 
 
 def test_ask_open_filename_linux_uses_zenity(
@@ -649,6 +655,7 @@ def fake_run(argv: list[str], **kwargs: object) -> object:
         assert argv[0] == "/usr/bin/zenity"
         assert "--file-selection" in argv
         assert any(arg.startswith("--filename=/tmp/") for arg in argv)
+        assert not any(arg.startswith("--file-filter=") for arg in argv)
         return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
 
     monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
@@ -658,6 +665,29 @@ def fake_run(argv: list[str], **kwargs: object) -> object:
     )
 
 
+def test_ask_open_filename_linux_applies_accept_filter(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+
+    def fake_run(argv: list[str], **kwargs: object) -> object:
+        assert "--file-filter=Accepted | *.png *.jpg" in argv
+        return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
+
+    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    assert (
+        native_window_module._ask_open_filename_linux(
+            initial_dir="/tmp",
+            accept=(".png", ".jpg"),
+        )
+        == "/tmp/seed.png"
+    )
+
+
 def test_ask_open_filename_linux_cancel_is_empty(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index b169f34d3..c88ba957f 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -16,8 +16,12 @@
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    MAX_SELECTED_FILE_BYTES,
     SelectedFile,
     SelectedFilesUserInputEvent,
+    clamp_selected_file_max_bytes,
+    normalize_selected_file_accept,
+    selected_file_suffix_allowed,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
@@ -70,6 +74,42 @@ def test_ui_loop_ignores_duplicate_file_selection_ids() -> None:
     assert len(requests.file_selections) == 1
     assert requests.file_selections[0].request_id == "open-1"
     assert requests.file_selections[0].initial_path == "/tmp"
+    assert requests.file_selections[0].accept == ()
+    assert requests.file_selections[0].max_bytes is None
+
+
+def test_ui_loop_queues_accept_and_max_bytes_without_clamping() -> None:
+    loop = _ui_loop()
+    loop.request_selected_files(
+        "open-1",
+        "/tmp",
+        accept=(".png", ".JPG"),
+        max_bytes=MAX_SELECTED_FILE_BYTES * 2,
+    )
+
+    requests = loop.flush_ui_loop_requests()
+    assert requests is not None
+    selection = requests.file_selections[0]
+    assert selection.accept == (".png", ".JPG")
+    assert selection.max_bytes == MAX_SELECTED_FILE_BYTES * 2
+
+
+def test_selected_file_policy_helpers() -> None:
+    assert clamp_selected_file_max_bytes(None) == MAX_SELECTED_FILE_BYTES
+    assert clamp_selected_file_max_bytes(16) == 16
+    assert clamp_selected_file_max_bytes(MAX_SELECTED_FILE_BYTES * 2) == (
+        MAX_SELECTED_FILE_BYTES
+    )
+    assert normalize_selected_file_accept([".png", ".jpg"]) == (".png", ".jpg")
+    assert selected_file_suffix_allowed("seed.PNG", (".png",))
+    assert not selected_file_suffix_allowed("seed.txt", (".png",))
+    assert selected_file_suffix_allowed("seed.txt", ())
+
+
+def test_ui_loop_rejects_invalid_accept() -> None:
+    loop = _ui_loop()
+    with pytest.raises(ValueError, match="accept suffixes"):
+        loop.request_selected_files("open-1", accept=("png",))
 
 
 def test_mp4_window_completes_file_selection_with_no_files(tmp_path: Path) -> None:
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index 3e984ba49..40fef46d1 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -7,7 +7,7 @@
 import queue
 import threading
 import time
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import replace
 from pathlib import Path
@@ -673,11 +673,18 @@ def request_lock_cursor_to_window(self, lock_cursor_to_window: bool) -> None:
         self.cursor_requests.append(("lock", lock_cursor_to_window))
 
     def request_selected_files(
-        self, request_id: str, initial_path: str | None = None
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
     ) -> None:
         """Record one file-selector request."""
         self._log.record("window.request_selected_files")
-        self.file_selection_requests.append((request_id, initial_path))
+        self.file_selection_requests.append(
+            (request_id, initial_path, tuple(accept), max_bytes)
+        )
 
     def get_user_input_events(self) -> UserInputEvents:
         self._log.record("window.get_user_input_events")
@@ -1381,13 +1388,18 @@ def init(self) -> None:
             super().init()
             invoke_async(
                 self.ui_loop,
-                lambda _: self.ui_loop.request_selected_files("open-1", "/tmp"),
+                lambda _: self.ui_loop.request_selected_files(
+                    "open-1",
+                    "/tmp",
+                    accept=(".png",),
+                    max_bytes=1024,
+                ),
             )
 
     window = RecordingClientWindow(log)
     run_session(RequestingSession(_session_desc(), log), window, steps=1)
 
-    assert window.file_selection_requests == [("open-1", "/tmp")]
+    assert window.file_selection_requests == [("open-1", "/tmp", (".png",), 1024)]
     assert "window.request_selected_files" in log.calls
 
 
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 54104613b..c56a8669a 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -36,6 +36,7 @@
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    MAX_SELECTED_FILE_BYTES,
     FocusUserInputEvent,
     GamepadUserInputEvent,
     GameWheelUserInputEvent,
@@ -51,6 +52,36 @@
 from flashdreams.runtime_v2.webrtc_client_window import WebRTCClientWindow
 
 
+def _files_url(window: WebRTCClientWindow, request_id: str) -> str:
+    return f"{window.server.url}api/files?request_id={request_id}"
+
+
+async def _wait_file_armed(window: WebRTCClientWindow, request_id: str) -> None:
+    for _ in range(100):
+        if request_id in window.server._pending_file_requests:
+            return
+        await asyncio.sleep(0.01)
+    raise AssertionError("file selection was not armed")
+
+
+async def _post_selected_file(
+    window: WebRTCClientWindow,
+    request_id: str,
+    data: bytes,
+    filename: str,
+) -> int:
+    form = FormData()
+    form.add_field(
+        "file",
+        data,
+        filename=filename,
+        content_type="application/octet-stream",
+    )
+    async with ClientSession() as client:
+        async with client.post(_files_url(window, request_id), data=form) as response:
+            return response.status
+
+
 def _session_desc(
     presentation_mode: PresentationMode = PresentationMode.ON_DEMAND,
 ) -> SessionDesc:
@@ -149,26 +180,9 @@ async def test_browser_file_upload_reaches_the_input_stream() -> None:
     try:
         window.request_selected_files("open-1", "/tmp")
         window.request_selected_files("open-1", "/tmp")
-        for _ in range(100):
-            if "open-1" in window.server._pending_file_request_ids:
-                break
-            await asyncio.sleep(0.01)
-        else:
-            raise AssertionError("file selection was not armed")
+        await _wait_file_armed(window, "open-1")
 
-        form = FormData()
-        form.add_field("request_id", "open-1")
-        form.add_field(
-            "file",
-            b"hello",
-            filename="hello.txt",
-            content_type="text/plain",
-        )
-        async with ClientSession() as client:
-            async with client.post(
-                f"{window.server.url}api/files", data=form
-            ) as response:
-                assert response.status == 204
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
 
         events = []
         for _ in range(100):
@@ -194,7 +208,6 @@ async def test_unsolicited_file_upload_is_rejected() -> None:
     window.open(_session_desc())
     try:
         form = FormData()
-        form.add_field("request_id", "open-1")
         form.add_field(
             "file",
             b"hello",
@@ -202,9 +215,7 @@ async def test_unsolicited_file_upload_is_rejected() -> None:
             content_type="text/plain",
         )
         async with ClientSession() as client:
-            async with client.post(
-                f"{window.server.url}api/files", data=form
-            ) as response:
+            async with client.post(_files_url(window, "open-1"), data=form) as response:
                 assert response.status == 409
         assert window.get_user_input_events().get_events() == []
     finally:
@@ -231,7 +242,12 @@ def on_message(message: object) -> None:
                 break
             await asyncio.sleep(0.01)
         payload = next(item for item in messages if item.get("type") == "file_selector")
-        assert payload == {"type": "file_selector", "id": "open-1"}
+        assert payload == {
+            "type": "file_selector",
+            "id": "open-1",
+            "accept": [],
+            "max_bytes": MAX_SELECTED_FILE_BYTES,
+        }
     finally:
         if peer is not None:
             await peer.close()
@@ -239,39 +255,99 @@ def on_message(message: object) -> None:
 
 
 @pytest.mark.asyncio
-async def test_session_handoff_clears_pending_file_selection() -> None:
+async def test_browser_file_selector_forwards_accept_and_clamps_max_bytes() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
     try:
-        window.request_selected_files("open-1", "/tmp")
+        peer, channel, _ = await _connect_browser(window)
+        messages: list[dict[str, object]] = []
+
+        @channel.on("message")
+        def on_message(message: object) -> None:
+            if isinstance(message, str):
+                messages.append(json.loads(message))
+
+        window.request_selected_files(
+            "open-1",
+            accept=(".png", ".jpg"),
+            max_bytes=MAX_SELECTED_FILE_BYTES * 2,
+        )
         for _ in range(100):
-            if "open-1" in window.server._pending_file_request_ids:
+            if any(item.get("type") == "file_selector" for item in messages):
                 break
             await asyncio.sleep(0.01)
-        else:
-            raise AssertionError("file selection was not armed")
+        payload = next(item for item in messages if item.get("type") == "file_selector")
+        assert payload == {
+            "type": "file_selector",
+            "id": "open-1",
+            "accept": [".png", ".jpg"],
+            "max_bytes": MAX_SELECTED_FILE_BYTES,
+        }
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
+async def _wait_selected_files_event(
+    window: WebRTCClientWindow,
+) -> SelectedFilesUserInputEvent:
+    events: list[object] = []
+    for _ in range(100):
+        events.extend(window.get_user_input_events().get_events())
+        if events:
+            break
+        await asyncio.sleep(0.01)
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    return event
+
+
+@pytest.mark.asyncio
+async def test_file_upload_rejects_disallowed_suffix() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", accept=(".png",))
+        await _wait_file_armed(window, "open-1")
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.files == ()
+    finally:
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_file_upload_rejects_oversize() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", max_bytes=1)
+        await _wait_file_armed(window, "open-1")
+        status = await _post_selected_file(window, "open-1", b"x" * 8192, "big.bin")
+        assert status == 413
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.files == ()
+    finally:
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_session_handoff_clears_pending_file_selection() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", "/tmp")
+        await _wait_file_armed(window, "open-1")
         window.open(_session_desc())
-        assert "open-1" not in window.server._pending_file_request_ids
+        assert "open-1" not in window.server._pending_file_requests
         window.request_selected_files("open-1", "/tmp")
-        for _ in range(100):
-            if "open-1" in window.server._pending_file_request_ids:
-                break
-            await asyncio.sleep(0.01)
-        else:
-            raise AssertionError("file selection was not re-armed")
-        form = FormData()
-        form.add_field("request_id", "open-1")
-        form.add_field(
-            "file",
-            b"hello",
-            filename="hello.txt",
-            content_type="text/plain",
-        )
-        async with ClientSession() as client:
-            async with client.post(
-                f"{window.server.url}api/files", data=form
-            ) as response:
-                assert response.status == 204
+        await _wait_file_armed(window, "open-1")
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
     finally:
         window.close()
 
@@ -353,7 +429,12 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert 'type: "touch"' in browser_script
                 assert "openFileSelector" in browser_script
                 assert 'type === "file_selector"' in browser_script
-                assert 'fetch("/api/files"' in browser_script
+                assert (
+                    "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`"
+                    in browser_script
+                )
+                assert "input.accept" in browser_script
+                assert "file.size" in browser_script
                 assert 'addEventListener("cancel"' in browser_script
                 assert "Choose file" in browser_page
                 assert "response.ok" in browser_script
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index 2142a9f35..fd976c4be 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -29,7 +29,8 @@ uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 Run the file-picker application. Native Linux needs `zenity` or `kdialog`
 (the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
 **Choose file** control in the viewer (the picker must open from a browser
-click). Picks larger than 32 MiB are rejected in every mode.
+click). The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Picks larger
+than 32 MiB are rejected in every mode.
 ```bash
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode native-window
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode webrtc \
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 91ce96693..49cf3ad5d 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -15,7 +15,10 @@
 from flashdreams.api_v2.session import ISession
 from flashdreams.runtime_v2.imgui_ui_loop import ImGuiUILoop
 from flashdreams.runtime_v2.session_desc import SessionDesc
-from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
+from flashdreams.runtime_v2.user_input_event import (
+    MAX_SELECTED_FILE_BYTES,
+    SelectedFilesUserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
 
@@ -31,7 +34,7 @@ class FilePickerState:
 
 
 class FilePickerImGuiUILoop(ImGuiUILoop[FilePickerState]):
-    """Request a client file pick and display the chosen name and size."""
+    """Request a ``.bin`` / ``.raw`` pick and show the chosen name and size."""
 
     def step_ui(
         self,
@@ -55,7 +58,11 @@ def step_ui(
         imgui.begin("File picker")
         try:
             if imgui.button("Open file"):
-                self.request_selected_files(uuid.uuid4().hex)
+                self.request_selected_files(
+                    uuid.uuid4().hex,
+                    accept=(".bin", ".raw"),
+                    max_bytes=MAX_SELECTED_FILE_BYTES,
+                )
             imgui.text(self.state.status)
         finally:
             imgui.end()
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 9d6ed5df3..34fadc745 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -16,6 +16,7 @@
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.user_input_event import (
+    MAX_SELECTED_FILE_BYTES,
     SelectedFile,
     SelectedFilesUserInputEvent,
 )
@@ -90,6 +91,8 @@ def test_open_file_button_requests_a_client_file() -> None:
     assert requests is not None
     assert len(requests.file_selections) == 1
     assert requests.file_selections[0].request_id
+    assert requests.file_selections[0].accept == (".bin", ".raw")
+    assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
 
 
 def test_selected_files_event_updates_file_picker_status() -> None:

From 7eaa5323cdd3fd424815375e1f2f5477e6c53d47 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 1 Oct 2026 15:56:10 -0700
Subject: [PATCH 07/43] Report distinct file-picker outcomes and classify type
 before size

Cancel, oversize, disallowed type, and unavailable are separate statuses. Windows share selected_file_policy_status so a too-large disallowed file is always disallowed_type. WebRTC confirms the request without freezing video; the demo overlay prints failures in red.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  13 +-
 .../flashdreams/api_v2/client_window.py       |   9 +-
 flashdreams/flashdreams/api_v2/loop.py        |  12 +-
 .../runtime_v2/mp4_client_window.py           |  15 +-
 .../runtime_v2/native_window_client_window.py |  43 ++-
 .../flashdreams/runtime_v2/serving/web/app.js | 270 +++++++++++++++---
 .../runtime_v2/serving/web/index.html         | 113 +++++++-
 .../runtime_v2/serving/webrtc_server.py       | 124 ++++----
 .../runtime_v2/user_input_event.py            |  69 ++++-
 .../runtime_v2/webrtc_client_window.py        |   4 +-
 .../test_native_window_client_window.py       |  69 +++--
 flashdreams/test_v2/test_selected_files.py    |  55 ++--
 .../test_v2/test_webrtc_client_window.py      | 104 ++++---
 integrations_v2/imgui_ui_demo/README.md       |   6 +-
 .../imgui_ui_demo/file_picker_app.py          |  83 +++++-
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  71 ++++-
 16 files changed, 804 insertions(+), 256 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index fdc618786..3cdcb7d40 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -226,12 +226,13 @@ description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. A control that needs a file from the client
 calls `request_selected_files(request_id, accept=..., max_bytes=...)`; the
 window later reports `SelectedFilesUserInputEvent` through the same input
-stream as keyboard and mouse. The application reads ``name`` and ``data`` from
-that event. ``accept`` (filename suffixes such as ``.png``) and ``max_bytes``
-are the application's policy; windows enforce them and clamp size to 32 MiB
-so a client cannot raise the cap. An empty ``files`` tuple is a cancelled or
-unavailable pick (including MP4, disallowed type, and files that exceed the
-budget).
+stream as keyboard and mouse. ``accept`` (filename suffixes such as ``.png``)
+and ``max_bytes`` are the application's policy; windows classify the choice
+with `selected_file_policy_status` (type before size) and clamp size to 32 MiB
+so a client cannot raise the cap. Empty ``accept`` (the default) allows any
+type; omit ``max_bytes`` to use the 32 MiB ceiling. Read ``status`` for the
+outcome (`ok`, `cancelled`, `too_large`, `disallowed_type`, `unavailable`);
+``files`` is non-empty only on `ok`.
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
 [`slangpy_ui_demo` integration](../../../integrations_v2/slangpy_ui_demo/README.md)
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 6e68f02d1..67f65f7ee 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -60,8 +60,13 @@ def request_selected_files(
         """Ask this client to pick files and report them as input events.
 
         The chosen files arrive later through
-        :meth:`InputSource.get_user_input_events`. Windows enforce ``accept``
-        and ``max_bytes`` and clamp the size to the 32 MiB ceiling.
+        :meth:`InputSource.get_user_input_events`. Windows classify the choice
+        with
+        :func:`~flashdreams.runtime_v2.user_input_event.selected_file_policy_status`
+        (type before size) and clamp size to the 32 MiB ceiling. The event
+        carries a ``status`` so cancel, oversize, and disallowed type are
+        distinct. Applications read that ``status``; they do not re-check type
+        or size.
 
         Args:
             request_id: Correlation token for the later input event.
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index d9d6ea9a5..0b07ab2a4 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -556,12 +556,16 @@ def request_selected_files(
 
         The window reports the result later as
         :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
-        A second call with the same ``request_id`` while the first is still
-        queued is ignored so the original picker can still complete.
+        Read ``status`` for cancel, oversize, disallowed type, or unavailable;
+        ``files`` is non-empty only when the pick succeeded. A second call with
+        the same ``request_id`` while the first is still queued is ignored so
+        the original picker can still complete.
 
         ``accept`` and ``max_bytes`` are the application's policy. Windows
-        enforce them and clamp ``max_bytes`` to the 32 MiB ceiling so a client
-        cannot raise the cap.
+        classify the choice with
+        :func:`~flashdreams.runtime_v2.user_input_event.selected_file_policy_status`
+        (type before size) and clamp ``max_bytes`` to the 32 MiB ceiling so a
+        client cannot raise the cap.
 
         Args:
             request_id: Correlation token for the later input event.
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index 23cc31598..5fa892c48 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -13,6 +13,7 @@
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     UserInputEvent,
 )
@@ -26,8 +27,8 @@ class Mp4ClientWindow(IClientWindow):
     event. Use ``BackpressureMode.BLOCK`` with
     ``PresentationMode.ON_DEMAND`` to write every frame once.
 
-    File-selector requests complete immediately with no files; there is no
-    client to pick one.
+    File-selector requests complete immediately as unavailable. This window
+    writes the run to a file; it has no interactive client.
     """
 
     def __init__(self, path: str | Path) -> None:
@@ -58,20 +59,20 @@ def request_selected_files(
         accept: Sequence[str] = (),
         max_bytes: int | None = None,
     ) -> None:
-        """Complete a file-selector request with no files.
+        """Complete a file-selector request as unavailable.
 
         Args:
             request_id: Correlation token from the UI loop.
-            initial_path: Ignored; an MP4 has no selector.
-            accept: Ignored; an MP4 has no selector.
-            max_bytes: Ignored; an MP4 has no selector.
+            initial_path: Ignored; this window has no selector.
+            accept: Ignored; this window has no selector.
+            max_bytes: Ignored; this window has no selector.
         """
         del initial_path, accept, max_bytes
         self._pending_events.append(
             SelectedFilesUserInputEvent(
                 timestamp=uint64(0),
                 request_id=request_id,
-                files=(),
+                status=SelectedFilesStatus.UNAVAILABLE,
             )
         )
 
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 98fedb9cf..897735eac 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -35,10 +35,11 @@
     KeyboardUserInputEvent,
     MouseUserInputEvent,
     SelectedFile,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     clamp_selected_file_max_bytes,
     normalize_selected_file_accept,
-    selected_file_suffix_allowed,
+    selected_file_policy_status,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -131,20 +132,30 @@ def _selected_file_from_path(
     *,
     accept: tuple[str, ...] = (),
     max_bytes: int | None = None,
-) -> SelectedFile | None:
-    """Load one picked file, or ``None`` when it cannot be used."""
+) -> tuple[SelectedFile | None, SelectedFilesStatus]:
+    """Load one picked file, or ``None`` and a failure status."""
     budget = MAX_SELECTED_FILE_BYTES if max_bytes is None else max_bytes
-    if not selected_file_suffix_allowed(path.name, accept):
-        return None
+    rejected = selected_file_policy_status(
+        path.name, None, accept=accept, max_bytes=budget
+    )
+    if rejected is not None:
+        return None, rejected
     try:
-        if path.stat().st_size > budget:
-            return None
+        size = path.stat().st_size
+        rejected = selected_file_policy_status(
+            path.name, size, accept=accept, max_bytes=budget
+        )
+        if rejected is not None:
+            return None, rejected
         data = path.read_bytes()
     except OSError:
-        return None
-    if len(data) > budget:
-        return None
-    return SelectedFile(name=path.name, data=data)
+        return None, SelectedFilesStatus.UNAVAILABLE
+    rejected = selected_file_policy_status(
+        path.name, len(data), accept=accept, max_bytes=budget
+    )
+    if rejected is not None:
+        return None, rejected
+    return SelectedFile(name=path.name, data=data), SelectedFilesStatus.OK
 
 
 _PRINTABLE_KEY_NAMES = {
@@ -328,15 +339,16 @@ def _complete_file_selection(
         """Run the OS picker and enqueue a selected-files event."""
         try:
             selected = _ask_open_filename(initial_dir=initial_dir, accept=accept)
-            files: tuple[SelectedFile, ...] = ()
             if selected:
-                chosen = _selected_file_from_path(
+                chosen, status = _selected_file_from_path(
                     Path(selected),
                     accept=accept,
                     max_bytes=max_bytes,
                 )
-                if chosen is not None:
-                    files = (chosen,)
+                files: tuple[SelectedFile, ...] = () if chosen is None else (chosen,)
+            else:
+                files = ()
+                status = SelectedFilesStatus.CANCELLED
             started_ns = self._session_started_ns
             elapsed_ns = (
                 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
@@ -345,6 +357,7 @@ def _complete_file_selection(
                 SelectedFilesUserInputEvent(
                     timestamp=uint64(elapsed_ns // 1_000),
                     request_id=request_id,
+                    status=status,
                     files=files,
                 )
             )
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 389b824b7..7f1e099b7 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -7,7 +7,12 @@ const pointerControls = peer.createDataChannel("pointer-controls");
 peer.addTransceiver("video", {direction: "recvonly"});
 const video = document.getElementById("video");
 const status = document.getElementById("status");
-const filePick = document.getElementById("file-pick");
+const promptDialog = document.getElementById("prompt-dialog");
+const promptBackdrop = document.getElementById("prompt-backdrop");
+const promptDialogTitle = document.getElementById("prompt-dialog-title");
+const promptDialogDetails = document.getElementById("prompt-dialog-details");
+const promptDialogConfirm = document.getElementById("prompt-dialog-confirm");
+const promptDialogCancel = document.getElementById("prompt-dialog-cancel");
 const pressedKeys = new Map();
 const pressedButtons = new Set();
 const gamepadSnapshots = new Map();
@@ -75,17 +80,166 @@ const applyCursorOptions = options => {
   }
 };
 
+let promptSettled = false;
+let promptOnConfirm = null;
+let promptOnCancel = null;
+
+const setPromptBackdropVisible = visible => {
+  if (promptBackdrop !== null) {
+    promptBackdrop.hidden = !visible;
+  }
+};
+
+const closePromptDialog = () => {
+  setPromptBackdropVisible(false);
+  if (promptDialog !== null && promptDialog.open) {
+    promptDialog.close();
+  }
+};
+
+const fillPromptDetails = details => {
+  if (promptDialogDetails === null) {
+    return;
+  }
+  promptDialogDetails.replaceChildren();
+  if (!Array.isArray(details) || details.length === 0) {
+    promptDialogDetails.hidden = true;
+    return;
+  }
+  for (const section of details) {
+    const row = document.createElement("div");
+    row.className = "prompt-dialog-row";
+    const label = document.createElement("div");
+    label.className = "prompt-dialog-detail-label";
+    label.textContent = section.label;
+    const value = document.createElement("div");
+    value.className = "prompt-dialog-row-value";
+    const values = Array.isArray(section.items) ? section.items : [];
+    for (const item of values) {
+      const chip = document.createElement("span");
+      chip.className = "prompt-dialog-chip";
+      chip.textContent = item;
+      value.append(chip);
+    }
+    row.append(label, value);
+    promptDialogDetails.append(row);
+  }
+  promptDialogDetails.hidden = false;
+};
+
+const showPromptDialog = ({
+  title,
+  details = [],
+  confirmLabel = "OK",
+  cancelLabel = "Cancel",
+  onConfirm = null,
+  onCancel = null,
+} = {}) => {
+  if (
+    promptDialog === null
+    || promptDialogTitle === null
+    || promptDialogConfirm === null
+    || promptDialogCancel === null
+  ) {
+    return;
+  }
+  if (promptDialog.open) {
+    promptSettled = true;
+    promptOnConfirm = null;
+    promptOnCancel = null;
+    promptDialog.close();
+  }
+  promptDialogTitle.textContent = title;
+  fillPromptDetails(details);
+  promptDialogConfirm.textContent = confirmLabel;
+  promptDialogCancel.textContent = cancelLabel;
+  promptOnConfirm = onConfirm;
+  promptOnCancel = onCancel;
+  promptSettled = false;
+  setPromptBackdropVisible(true);
+  promptDialog.show();
+  promptDialogConfirm.focus();
+};
+
+if (promptDialog !== null) {
+  promptDialogConfirm?.addEventListener("click", () => {
+    if (promptSettled) {
+      return;
+    }
+    promptSettled = true;
+    const onConfirm = promptOnConfirm;
+    promptOnConfirm = null;
+    promptOnCancel = null;
+    closePromptDialog();
+    onConfirm?.();
+  });
+  promptDialogCancel?.addEventListener("click", () => {
+    if (promptSettled) {
+      return;
+    }
+    promptSettled = true;
+    const onCancel = promptOnCancel;
+    promptOnConfirm = null;
+    promptOnCancel = null;
+    closePromptDialog();
+    onCancel?.();
+  });
+  promptDialog.addEventListener("close", () => {
+    setPromptBackdropVisible(false);
+    if (promptSettled) {
+      return;
+    }
+    promptSettled = true;
+    const onCancel = promptOnCancel;
+    promptOnConfirm = null;
+    promptOnCancel = null;
+    onCancel?.();
+  });
+}
+
+window.addEventListener("keydown", event => {
+  if (event.key !== "Escape" || promptDialog === null || !promptDialog.open) {
+    return;
+  }
+  event.preventDefault();
+  promptDialogCancel?.click();
+});
+
+if (promptBackdrop !== null) {
+  promptBackdrop.addEventListener("click", () => {
+    promptDialogCancel?.click();
+  });
+}
+
 let pendingFileRequest = null;
 
 const hideFilePicker = () => {
   pendingFileRequest = null;
-  if (filePick !== null) {
-    filePick.hidden = true;
+  if (promptDialog !== null && promptDialog.open) {
+    promptSettled = true;
+    promptOnConfirm = null;
+    promptOnCancel = null;
+    closePromptDialog();
   }
 };
 
-const cancelFileSelection = requestId => {
-  send({type: "file_selector_result", id: requestId, cancelled: true});
+const completeFileSelection = (requestId, status) => {
+  send({type: "file_selector_result", id: requestId, status});
+};
+
+const formatByteBudget = bytes => {
+  if (!Number.isFinite(bytes) || bytes <= 0) {
+    return "the allowed size";
+  }
+  const mib = bytes / (1024 * 1024);
+  if (mib >= 1) {
+    return Number.isInteger(mib) ? `${mib} MiB` : `${mib.toFixed(1)} MiB`;
+  }
+  const kib = bytes / 1024;
+  if (kib >= 1) {
+    return Number.isInteger(kib) ? `${kib} KiB` : `${kib.toFixed(1)} KiB`;
+  }
+  return `${bytes} bytes`;
 };
 
 const fileNameMatchesAccept = (name, accept) => {
@@ -98,55 +252,47 @@ const fileNameMatchesAccept = (name, accept) => {
   );
 };
 
-const openFileSelector = options => {
-  const requestId = options?.id;
-  if (typeof requestId !== "string" || !requestId || filePick === null) {
-    return;
+const selectedFilePolicyStatus = (name, size, accept, maxBytes) => {
+  // Same order as selected_file_policy_status: type, then size.
+  if (!fileNameMatchesAccept(name, accept)) {
+    return "disallowed_type";
   }
-  if (pendingFileRequest !== null && pendingFileRequest.id !== requestId) {
-    cancelFileSelection(pendingFileRequest.id);
+  if (size > maxBytes) {
+    return "too_large";
   }
-  const accept = Array.isArray(options.accept) ? options.accept : [];
-  const maxBytes = Number(options.max_bytes);
-  pendingFileRequest = {
-    id: requestId,
-    accept,
-    maxBytes: Number.isFinite(maxBytes) ? maxBytes : 0,
-  };
-  filePick.hidden = false;
+  return null;
 };
 
-filePick?.addEventListener("click", () => {
-  const pending = pendingFileRequest;
-  const requestId = pending?.id;
-  if (typeof requestId !== "string" || !requestId || pending === null) {
-    return;
-  }
+const startFileInput = pending => {
+  const requestId = pending.id;
   const input = document.createElement("input");
   input.type = "file";
   if (pending.accept.length > 0) {
     input.accept = pending.accept.join(",");
   }
   let settled = false;
-  const finishCancelled = () => {
+  const finishFileSelection = status => {
     if (settled || pendingFileRequest === null || pendingFileRequest.id !== requestId) {
       return;
     }
     settled = true;
-    cancelFileSelection(requestId);
+    completeFileSelection(requestId, status);
     hideFilePicker();
   };
   input.addEventListener("change", () => {
     const file = input.files?.[0];
     if (!file) {
-      finishCancelled();
+      finishFileSelection("cancelled");
       return;
     }
-    if (
-      !fileNameMatchesAccept(file.name || "", pending.accept)
-      || file.size > pending.maxBytes
-    ) {
-      finishCancelled();
+    const rejected = selectedFilePolicyStatus(
+      file.name || "",
+      file.size,
+      pending.accept,
+      pending.maxBytes,
+    );
+    if (rejected !== null) {
+      finishFileSelection(rejected);
       return;
     }
     const body = new FormData();
@@ -159,21 +305,65 @@ filePick?.addEventListener("click", () => {
         if (settled || pendingFileRequest === null || pendingFileRequest.id !== requestId) {
           return;
         }
-        if (!response.ok) {
-          finishCancelled();
-          return;
-        }
         settled = true;
         hideFilePicker();
+        if (!response.ok) {
+          console.debug("File upload was rejected.", response.status);
+        }
       })
       .catch(error => {
         console.debug("Unable to upload the selected file.", error);
-        finishCancelled();
+        finishFileSelection("unavailable");
       });
   });
-  input.addEventListener("cancel", finishCancelled);
+  input.addEventListener("cancel", () => finishFileSelection("cancelled"));
   input.click();
-});
+};
+
+const openFileSelector = options => {
+  const requestId = options?.id;
+  if (typeof requestId !== "string" || !requestId) {
+    return;
+  }
+  if (pendingFileRequest !== null && pendingFileRequest.id !== requestId) {
+    completeFileSelection(pendingFileRequest.id, "cancelled");
+  }
+  const accept = Array.isArray(options.accept) ? options.accept : [];
+  const maxBytes = Number(options.max_bytes);
+  pendingFileRequest = {
+    id: requestId,
+    accept,
+    maxBytes: Number.isFinite(maxBytes) ? maxBytes : 0,
+  };
+  showPromptDialog({
+    title: "The app wants to open a file",
+    details: [
+      {
+        label: "Accepted types",
+        items: accept.length > 0 ? accept : ["Any"],
+      },
+      {
+        label: "Max size allowed",
+        items: [formatByteBudget(pendingFileRequest.maxBytes)],
+      },
+    ],
+    confirmLabel: "Open",
+    onConfirm: () => {
+      const pending = pendingFileRequest;
+      if (pending === null || pending.id !== requestId) {
+        return;
+      }
+      startFileInput(pending);
+    },
+    onCancel: () => {
+      if (pendingFileRequest === null || pendingFileRequest.id !== requestId) {
+        return;
+      }
+      completeFileSelection(requestId, "cancelled");
+      pendingFileRequest = null;
+    },
+  });
+};
 
 window.addEventListener("focus", updateCursorVisibility);
 window.addEventListener("blur", updateCursorVisibility);
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/index.html b/flashdreams/flashdreams/runtime_v2/serving/web/index.html
index c5d453f17..a7114767f 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/index.html
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/index.html
@@ -48,31 +48,120 @@
         color: #ff8a8a;
       }
 
-      #file-pick {
+      #prompt-backdrop {
         position: fixed;
-        left: 50%;
-        bottom: 1.5rem;
-        transform: translateX(-50%);
+        inset: 0;
         z-index: 2;
-        padding: 0.6rem 1.1rem;
-        border: 0;
-        border-radius: 0.4rem;
-        background: #eee;
-        color: #111;
+        background: rgb(0 0 0 / 28%);
+      }
+
+      #prompt-backdrop[hidden] {
+        display: none;
+      }
+
+      #prompt-dialog {
+        position: fixed;
+        inset: 0;
+        z-index: 3;
+        margin: auto;
+        height: fit-content;
+        color-scheme: light dark;
+        max-width: 26rem;
+        width: min(26rem, calc(100% - 2rem));
+        padding: 1.25rem 1.35rem 1rem;
+        border: 1px solid color-mix(in srgb, CanvasText 18%, Canvas);
+        border-radius: 12px;
+        background: Canvas;
+        color: CanvasText;
         font: inherit;
-        cursor: pointer;
+        box-shadow: 0 18px 40px rgb(0 0 0 / 45%);
       }
 
-      #file-pick[hidden] {
+      #prompt-dialog-title {
+        margin: 0 0 0.9rem;
+        font-size: 1.1rem;
+        font-weight: 650;
+      }
+
+      #prompt-dialog-details {
+        display: grid;
+        grid-template-columns: max-content minmax(0, 1fr);
+        align-items: baseline;
+        column-gap: 0.85rem;
+        row-gap: 0.4rem;
+        margin: 0 0 1.15rem;
+      }
+
+      #prompt-dialog-details[hidden] {
         display: none;
       }
 
+      .prompt-dialog-row {
+        display: contents;
+      }
+
+      .prompt-dialog-detail-label {
+        margin: 0;
+        font-size: 0.85rem;
+        color: color-mix(in srgb, CanvasText 62%, Canvas);
+        text-align: end;
+        white-space: nowrap;
+      }
+
+      .prompt-dialog-detail-label::after {
+        content: ":";
+      }
+
+      .prompt-dialog-row-value {
+        display: flex;
+        flex-wrap: wrap;
+        column-gap: 0.55rem;
+        row-gap: 0.15rem;
+      }
+
+      .prompt-dialog-chip {
+        font-size: 0.95rem;
+      }
+
+      .prompt-dialog-actions {
+        display: flex;
+        justify-content: flex-end;
+        gap: 0.55rem;
+      }
+
+      .prompt-dialog-actions button {
+        font: inherit;
+        padding: 0.45rem 0.95rem;
+        border-radius: 0.45rem;
+        cursor: pointer;
+      }
+
+      #prompt-dialog-cancel {
+        border: 1px solid color-mix(in srgb, CanvasText 28%, Canvas);
+        background: transparent;
+        color: CanvasText;
+      }
+
+      #prompt-dialog-confirm {
+        border: 0;
+        background: CanvasText;
+        color: Canvas;
+      }
+
     </style>
   </head>
   <body>
     <video id="video" autoplay muted playsinline></video>
     <div id="status" role="status" aria-live="polite">Waiting for the server…</div>
-    <button id="file-pick" type="button" hidden>Choose file</button>
+    <div id="prompt-backdrop" hidden></div>
+    <dialog id="prompt-dialog" aria-labelledby="prompt-dialog-title">
+      <h2 id="prompt-dialog-title"></h2>
+      <div id="prompt-dialog-details" hidden></div>
+      <div class="prompt-dialog-actions">
+        <button type="button" id="prompt-dialog-cancel">Cancel</button>
+        <button type="button" id="prompt-dialog-confirm">Open</button>
+      </div>
+    </dialog>
     <script src="/app.js"></script>
   </body>
 </html>
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 61f22413f..db655bb2d 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -43,13 +43,14 @@
     QueryStringUserInputEvent,
     ResetUserInputEvent,
     SelectedFile,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     UserInputEvent,
     XRControllerUserInputEvent,
     clamp_selected_file_max_bytes,
     normalize_selected_file_accept,
-    selected_file_suffix_allowed,
+    selected_file_policy_status,
 )
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
 
@@ -301,10 +302,6 @@ async def _next_queued_frame(self) -> _QueuedRGBFrame:
             await self._frame_available.wait()
 
 
-_FILE_UPLOAD_HEADER_SLACK_BYTES = 4 * 1024
-"""Multipart wrapper bytes allowed on top of a selected-file size budget."""
-
-
 @dataclass(frozen=True, slots=True)
 class _PendingFileSelection:
     """Accept suffixes and size budget for one armed file-selector request."""
@@ -523,7 +520,7 @@ def _invalidate_file_selectors(self) -> None:
             self._queued_file_selectors.clear()
 
     def _complete_abandoned_file_selectors(self) -> None:
-        """Complete pending selector requests with empty files."""
+        """Complete pending selector requests as unavailable."""
         timestamp_us = self._timestamp_us()
         with self._file_selector_lock:
             pending = tuple(self._pending_file_requests)
@@ -532,12 +529,10 @@ def _complete_abandoned_file_selectors(self) -> None:
         if timestamp_us is None:
             return
         for request_id in pending:
-            self._append_event(
-                SelectedFilesUserInputEvent(
-                    timestamp=timestamp_us,
-                    request_id=request_id,
-                    files=(),
-                )
+            self._emit_selected_files(
+                timestamp_us,
+                request_id,
+                status=SelectedFilesStatus.UNAVAILABLE,
             )
 
     def _send_file_selector(self, payload: dict[str, Any]) -> None:
@@ -898,67 +893,50 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
             raise web.HTTPConflict(
                 reason="No pending file selection for this request_id."
             )
-        content_length = request.content_length
-        if (
-            content_length is not None
-            and content_length > policy.max_bytes + _FILE_UPLOAD_HEADER_SLACK_BYTES
-        ):
-            self._append_event(
-                SelectedFilesUserInputEvent(
-                    timestamp=timestamp_us,
-                    request_id=request_id,
-                    files=(),
-                )
-            )
-            raise web.HTTPRequestEntityTooLarge(
-                max_size=policy.max_bytes,
-                actual_size=content_length,
-            )
         try:
             post = await request.post()
         except web.HTTPRequestEntityTooLarge:
-            self._append_event(
-                SelectedFilesUserInputEvent(
-                    timestamp=timestamp_us,
-                    request_id=request_id,
-                    files=(),
-                )
+            self._emit_selected_files(
+                timestamp_us,
+                request_id,
+                status=SelectedFilesStatus.TOO_LARGE,
             )
             raise
         upload = post.get("file")
         if not isinstance(upload, FileField):
-            self._append_event(
-                SelectedFilesUserInputEvent(
-                    timestamp=timestamp_us,
-                    request_id=request_id,
-                    files=(),
-                )
+            self._emit_selected_files(
+                timestamp_us,
+                request_id,
+                status=SelectedFilesStatus.UNAVAILABLE,
             )
             raise web.HTTPBadRequest(reason="File upload requires a file.")
         data = upload.file.read()
         name = upload.filename or "upload"
-        if len(data) > policy.max_bytes or not selected_file_suffix_allowed(
-            name, policy.accept
-        ):
-            self._append_event(
-                SelectedFilesUserInputEvent(
-                    timestamp=timestamp_us,
-                    request_id=request_id,
-                    files=(),
-                )
+        rejected = selected_file_policy_status(
+            name, len(data), accept=policy.accept, max_bytes=policy.max_bytes
+        )
+        if rejected is SelectedFilesStatus.DISALLOWED_TYPE:
+            self._emit_selected_files(
+                timestamp_us,
+                request_id,
+                status=rejected,
             )
-            if len(data) > policy.max_bytes:
-                raise web.HTTPRequestEntityTooLarge(
-                    max_size=policy.max_bytes,
-                    actual_size=len(data),
-                )
             return web.Response(status=204)
-        self._append_event(
-            SelectedFilesUserInputEvent(
-                timestamp=timestamp_us,
-                request_id=request_id,
-                files=(SelectedFile(name=name, data=data),),
+        if rejected is SelectedFilesStatus.TOO_LARGE:
+            self._emit_selected_files(
+                timestamp_us,
+                request_id,
+                status=rejected,
+            )
+            raise web.HTTPRequestEntityTooLarge(
+                max_size=policy.max_bytes,
+                actual_size=len(data),
             )
+        self._emit_selected_files(
+            timestamp_us,
+            request_id,
+            status=SelectedFilesStatus.OK,
+            files=(SelectedFile(name=name, data=data),),
         )
         return web.Response(status=204)
 
@@ -1287,9 +1265,13 @@ def _buffer_browser_message(
             request_id = payload.get("id")
             if not isinstance(request_id, str) or not request_id:
                 raise ValueError("File selector result requires a non-empty id.")
-            if payload.get("cancelled") is not True:
+            try:
+                status = SelectedFilesStatus(payload.get("status"))
+            except ValueError as error:
+                raise ValueError("File selector result status is invalid.") from error
+            if status is SelectedFilesStatus.OK:
                 raise ValueError(
-                    "File selector result must set cancelled true; send files "
+                    "File selector result must not set status ok; send files "
                     "with POST /api/files."
                 )
             if self._take_pending_file_request(request_id) is None:
@@ -1297,7 +1279,7 @@ def _buffer_browser_message(
             event = SelectedFilesUserInputEvent(
                 timestamp=timestamp_us,
                 request_id=request_id,
-                files=(),
+                status=status,
             )
         else:
             raise ValueError("Unsupported browser event type.")
@@ -1310,6 +1292,24 @@ def _append_event(self, event: UserInputEvent) -> None:
             raise RuntimeError("WebRTC input callback is not registered.")
         callback(event)
 
+    def _emit_selected_files(
+        self,
+        timestamp_us: np.uint64,
+        request_id: str,
+        *,
+        status: SelectedFilesStatus,
+        files: tuple[SelectedFile, ...] = (),
+    ) -> None:
+        """Append one selected-files event."""
+        self._append_event(
+            SelectedFilesUserInputEvent(
+                timestamp=timestamp_us,
+                request_id=request_id,
+                status=status,
+                files=files,
+            )
+        )
+
     async def _release_peer_connection(
         self,
         peer_connection: RTCPeerConnection,
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 52bde919f..203839452 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -299,6 +299,55 @@ def get_type_name(cls) -> str:
     """Optional controller quaternion in client XR space."""
 
 
+class SelectedFilesStatus(Enum):
+    """Outcome of one client file-selector request."""
+
+    OK = "ok"
+    """The client chose a file that passed type and size checks."""
+
+    CANCELLED = "cancelled"
+    """The user dismissed the selector."""
+
+    TOO_LARGE = "too_large"
+    """The chosen file exceeded ``max_bytes``."""
+
+    DISALLOWED_TYPE = "disallowed_type"
+    """The chosen file did not match ``accept``. Checked before size."""
+
+    UNAVAILABLE = "unavailable"
+    """No picker could run: ``--mode mp4``, a dropped peer, or an unreadable file."""
+
+
+def selected_file_policy_status(
+    name: str,
+    size: int | None,
+    *,
+    accept: tuple[str, ...] = (),
+    max_bytes: int,
+) -> SelectedFilesStatus | None:
+    """Return why a chosen file is rejected, or ``None`` if it is allowed.
+
+    Windows call this so every client uses the same order: type before size.
+    A too-large disallowed file is ``DISALLOWED_TYPE``. Applications only read
+    :class:`SelectedFilesUserInputEvent` ``status``. Pass ``size=None`` to
+    check only the name.
+
+    Args:
+        name: File name to match against ``accept``.
+        size: File size in bytes, or ``None`` to skip the size check.
+        accept: Filename suffixes such as ``.png``. Empty allows any type.
+        max_bytes: Maximum allowed size in bytes.
+
+    Returns:
+        ``DISALLOWED_TYPE``, ``TOO_LARGE``, or ``None`` when the file passes.
+    """
+    if not selected_file_suffix_allowed(name, accept):
+        return SelectedFilesStatus.DISALLOWED_TYPE
+    if size is not None and size > max_bytes:
+        return SelectedFilesStatus.TOO_LARGE
+    return None
+
+
 @dataclass(frozen=True, slots=True)
 class SelectedFile:
     """One file chosen by a client file selector."""
@@ -314,9 +363,8 @@ class SelectedFile:
 class SelectedFilesUserInputEvent(UserInputEvent):
     """Files chosen for one :meth:`IClientWindow.request_selected_files` call.
 
-    An empty ``files`` tuple is a cancelled or unavailable selector: dismiss,
-    oversize, disallowed type, unreadable, a dropped WebRTC peer, or
-    ``--mode mp4``.
+    ``status`` is why the request completed. ``OK`` is the only value with
+    files; every other value uses an empty ``files`` tuple.
     """
 
     @classmethod
@@ -327,8 +375,21 @@ def get_type_name(cls) -> str:
     request_id: str
     """Identifier supplied with the matching file-selection request."""
 
+    status: SelectedFilesStatus
+    """Why this request completed. ``OK`` is the only value with files."""
+
     files: tuple[SelectedFile, ...] = ()
-    """Chosen files, empty when the selector was cancelled or unavailable."""
+    """Chosen files. Empty unless ``status`` is ``OK``."""
+
+    def __post_init__(self) -> None:
+        """Reject an ``ok`` event without files, or files on a failed pick."""
+        has_files = bool(self.files)
+        if self.status is SelectedFilesStatus.OK:
+            if not has_files:
+                raise ValueError("ok selected-files events must include files.")
+            return
+        if has_files:
+            raise ValueError("failed selected-files events must not include files.")
 
 
 @dataclass(frozen=True, slots=True, eq=False)
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 94da59585..8b7026611 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -124,8 +124,8 @@ def request_selected_files(
             request_id: Correlation token for the later input event.
             initial_path: Ignored by the browser picker; kept so the window
                 signature matches :meth:`IClientWindow.request_selected_files`.
-            accept: Filename suffixes forwarded to the browser picker.
-            max_bytes: Size budget forwarded to the browser and upload handler.
+            accept: Filename suffixes such as ``.png``. Empty allows any type.
+            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
         """
         if request_id in self._in_flight_file_requests:
             _LOGGER.warning(
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 32b0a8476..65a232910 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -29,6 +29,7 @@
     KeyboardInputState,
     KeyboardUserInputEvent,
     MouseUserInputEvent,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -620,26 +621,57 @@ def test_native_window_reports_a_selected_file(
     event = events[0]
     assert isinstance(event, SelectedFilesUserInputEvent)
     assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.OK
     assert event.files[0].name == "seed.png"
     assert event.files[0].data == b"png-bytes"
 
 
+def test_native_window_reports_cancelled_file_selection(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(
+        native_window_module,
+        "_ask_open_filename",
+        lambda *, initial_dir, accept=(): "",
+    )
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.CANCELLED
+    assert event.files == ()
+
+
 def test_selected_file_from_path_skips_unreadable_and_oversize(
     tmp_path: Path,
 ) -> None:
     missing = tmp_path / "gone.png"
-    assert native_window_module._selected_file_from_path(missing) is None
+    chosen, status = native_window_module._selected_file_from_path(missing)
+    assert chosen is None
+    assert status is SelectedFilesStatus.UNAVAILABLE
 
     too_big = tmp_path / "big.bin"
     too_big.write_bytes(b"abcd")
-    assert native_window_module._selected_file_from_path(too_big, max_bytes=3) is None
+    chosen, status = native_window_module._selected_file_from_path(too_big, max_bytes=3)
+    assert chosen is None
+    assert status is SelectedFilesStatus.TOO_LARGE
 
     wrong_type = tmp_path / "notes.txt"
     wrong_type.write_bytes(b"hi")
-    assert (
-        native_window_module._selected_file_from_path(wrong_type, accept=(".png",))
-        is None
+    chosen, status = native_window_module._selected_file_from_path(
+        wrong_type, accept=(".png",)
     )
+    assert chosen is None
+    assert status is SelectedFilesStatus.DISALLOWED_TYPE
 
 
 def test_ask_open_filename_linux_uses_zenity(
@@ -650,12 +682,10 @@ def test_ask_open_filename_linux_uses_zenity(
         "which",
         lambda name: "/usr/bin/zenity" if name == "zenity" else None,
     )
+    calls: list[list[str]] = []
 
     def fake_run(argv: list[str], **kwargs: object) -> object:
-        assert argv[0] == "/usr/bin/zenity"
-        assert "--file-selection" in argv
-        assert any(arg.startswith("--filename=/tmp/") for arg in argv)
-        assert not any(arg.startswith("--file-filter=") for arg in argv)
+        calls.append(argv)
         return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
 
     monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
@@ -663,22 +693,10 @@ def fake_run(argv: list[str], **kwargs: object) -> object:
         native_window_module._ask_open_filename_linux(initial_dir="/tmp")
         == "/tmp/seed.png"
     )
-
-
-def test_ask_open_filename_linux_applies_accept_filter(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-
-    def fake_run(argv: list[str], **kwargs: object) -> object:
-        assert "--file-filter=Accepted | *.png *.jpg" in argv
-        return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
-
-    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    assert calls[0][0] == "/usr/bin/zenity"
+    assert "--file-selection" in calls[0]
+    assert any(arg.startswith("--filename=/tmp/") for arg in calls[0])
+    assert not any(arg.startswith("--file-filter=") for arg in calls[0])
     assert (
         native_window_module._ask_open_filename_linux(
             initial_dir="/tmp",
@@ -686,6 +704,7 @@ def fake_run(argv: list[str], **kwargs: object) -> object:
         )
         == "/tmp/seed.png"
     )
+    assert "--file-filter=Accepted | *.png *.jpg" in calls[1]
 
 
 def test_ask_open_filename_linux_cancel_is_empty(
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index c88ba957f..b24d85f10 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -18,9 +18,11 @@
 from flashdreams.runtime_v2.user_input_event import (
     MAX_SELECTED_FILE_BYTES,
     SelectedFile,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     clamp_selected_file_max_bytes,
     normalize_selected_file_accept,
+    selected_file_policy_status,
     selected_file_suffix_allowed,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
@@ -56,29 +58,17 @@ def test_selected_files_event_carries_bytes_and_request_id() -> None:
     event = SelectedFilesUserInputEvent(
         timestamp=uint64(1),
         request_id="open-1",
+        status=SelectedFilesStatus.OK,
         files=(SelectedFile(name="seed.png", data=b"png"),),
     )
 
     assert event.get_type_name() == "selected_files"
     assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.OK
     assert event.files[0].data == b"png"
 
 
-def test_ui_loop_ignores_duplicate_file_selection_ids() -> None:
-    loop = _ui_loop()
-    loop.request_selected_files("open-1", "/tmp")
-    loop.request_selected_files("open-1", "/var")
-
-    requests = loop.flush_ui_loop_requests()
-    assert requests is not None
-    assert len(requests.file_selections) == 1
-    assert requests.file_selections[0].request_id == "open-1"
-    assert requests.file_selections[0].initial_path == "/tmp"
-    assert requests.file_selections[0].accept == ()
-    assert requests.file_selections[0].max_bytes is None
-
-
-def test_ui_loop_queues_accept_and_max_bytes_without_clamping() -> None:
+def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     loop = _ui_loop()
     loop.request_selected_files(
         "open-1",
@@ -86,10 +76,14 @@ def test_ui_loop_queues_accept_and_max_bytes_without_clamping() -> None:
         accept=(".png", ".JPG"),
         max_bytes=MAX_SELECTED_FILE_BYTES * 2,
     )
+    loop.request_selected_files("open-1", "/var")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
+    assert len(requests.file_selections) == 1
     selection = requests.file_selections[0]
+    assert selection.request_id == "open-1"
+    assert selection.initial_path == "/tmp"
     assert selection.accept == (".png", ".JPG")
     assert selection.max_bytes == MAX_SELECTED_FILE_BYTES * 2
 
@@ -104,6 +98,18 @@ def test_selected_file_policy_helpers() -> None:
     assert selected_file_suffix_allowed("seed.PNG", (".png",))
     assert not selected_file_suffix_allowed("seed.txt", (".png",))
     assert selected_file_suffix_allowed("seed.txt", ())
+    assert (
+        selected_file_policy_status("seed.txt", 99, accept=(".png",), max_bytes=3)
+        is SelectedFilesStatus.DISALLOWED_TYPE
+    )
+    assert (
+        selected_file_policy_status("seed.png", 99, accept=(".png",), max_bytes=3)
+        is SelectedFilesStatus.TOO_LARGE
+    )
+    assert (
+        selected_file_policy_status("seed.png", 2, accept=(".png",), max_bytes=3)
+        is None
+    )
 
 
 def test_ui_loop_rejects_invalid_accept() -> None:
@@ -112,7 +118,23 @@ def test_ui_loop_rejects_invalid_accept() -> None:
         loop.request_selected_files("open-1", accept=("png",))
 
 
-def test_mp4_window_completes_file_selection_with_no_files(tmp_path: Path) -> None:
+def test_selected_files_event_rejects_inconsistent_status() -> None:
+    with pytest.raises(ValueError, match="must include files"):
+        SelectedFilesUserInputEvent(
+            timestamp=uint64(1),
+            request_id="open-1",
+            status=SelectedFilesStatus.OK,
+        )
+    with pytest.raises(ValueError, match="must not include files"):
+        SelectedFilesUserInputEvent(
+            timestamp=uint64(1),
+            request_id="open-1",
+            status=SelectedFilesStatus.CANCELLED,
+            files=(SelectedFile(name="seed.png", data=b"png"),),
+        )
+
+
+def test_mp4_window_completes_file_selection_as_unavailable(tmp_path: Path) -> None:
     window = Mp4ClientWindow(tmp_path / "clip.mp4")
     window.request_selected_files("open-1", "/tmp")
 
@@ -122,5 +144,6 @@ def test_mp4_window_completes_file_selection_with_no_files(tmp_path: Path) -> No
     event = events[0]
     assert isinstance(event, SelectedFilesUserInputEvent)
     assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.UNAVAILABLE
     assert event.files == ()
     assert window.get_user_input_events().get_events() == []
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index c56a8669a..cfe7ce9d8 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -44,6 +44,7 @@
     KeyboardUserInputEvent,
     MouseUserInputEvent,
     QueryStringUserInputEvent,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     XRControllerUserInputEvent,
@@ -194,10 +195,9 @@ async def test_browser_file_upload_reaches_the_input_stream() -> None:
         event = events[0]
         assert isinstance(event, SelectedFilesUserInputEvent)
         assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.OK
         assert event.files[0].name == "hello.txt"
         assert event.files[0].data == b"hello"
-
-        window.request_selected_files("open-1", "/tmp")
     finally:
         window.close()
 
@@ -223,39 +223,7 @@ async def test_unsolicited_file_upload_is_rejected() -> None:
 
 
 @pytest.mark.asyncio
-async def test_browser_file_selector_omits_host_path() -> None:
-    window = WebRTCClientWindow()
-    window.open(_session_desc())
-    peer: RTCPeerConnection | None = None
-    try:
-        peer, channel, _ = await _connect_browser(window)
-        messages: list[dict[str, object]] = []
-
-        @channel.on("message")
-        def on_message(message: object) -> None:
-            if isinstance(message, str):
-                messages.append(json.loads(message))
-
-        window.request_selected_files("open-1", "/home/secret")
-        for _ in range(100):
-            if any(item.get("type") == "file_selector" for item in messages):
-                break
-            await asyncio.sleep(0.01)
-        payload = next(item for item in messages if item.get("type") == "file_selector")
-        assert payload == {
-            "type": "file_selector",
-            "id": "open-1",
-            "accept": [],
-            "max_bytes": MAX_SELECTED_FILE_BYTES,
-        }
-    finally:
-        if peer is not None:
-            await peer.close()
-        window.close()
-
-
-@pytest.mark.asyncio
-async def test_browser_file_selector_forwards_accept_and_clamps_max_bytes() -> None:
+async def test_browser_file_selector_sends_clamped_policy_without_host_path() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     peer: RTCPeerConnection | None = None
@@ -270,6 +238,7 @@ def on_message(message: object) -> None:
 
         window.request_selected_files(
             "open-1",
+            "/home/secret",
             accept=(".png", ".jpg"),
             max_bytes=MAX_SELECTED_FILE_BYTES * 2,
         )
@@ -315,6 +284,7 @@ async def test_file_upload_rejects_disallowed_suffix() -> None:
         assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.DISALLOWED_TYPE
         assert event.files == ()
     finally:
         window.close()
@@ -331,11 +301,59 @@ async def test_file_upload_rejects_oversize() -> None:
         assert status == 413
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.TOO_LARGE
         assert event.files == ()
     finally:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_file_upload_prefers_disallowed_suffix_over_oversize() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", accept=(".png",), max_bytes=1)
+        await _wait_file_armed(window, "open-1")
+        assert (
+            await _post_selected_file(window, "open-1", b"x" * 8192, "hello.txt")
+            == 204
+        )
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.DISALLOWED_TYPE
+        assert event.files == ()
+    finally:
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_browser_file_selector_result_reports_status() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, channel, _ = await _connect_browser(window)
+        window.request_selected_files("open-1")
+        await _wait_file_armed(window, "open-1")
+        channel.send(
+            json.dumps(
+                {
+                    "type": "file_selector_result",
+                    "id": "open-1",
+                    "status": "cancelled",
+                }
+            )
+        )
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.CANCELLED
+        assert event.files == ()
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_session_handoff_clears_pending_file_selection() -> None:
     window = WebRTCClientWindow()
@@ -390,7 +408,10 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert 'id="reset"' not in browser_page
                 assert '<video id="video" autoplay muted playsinline>' in browser_page
                 assert 'id="status"' in browser_page
-                assert 'id="file-pick"' in browser_page
+                assert 'id="prompt-dialog"' in browser_page
+                assert 'id="prompt-dialog-confirm"' in browser_page
+                assert 'id="prompt-dialog-details"' in browser_page
+                assert 'id="prompt-backdrop"' in browser_page
                 assert '<script src="/app.js"></script>' in browser_page
             async with client.get(f"{window.server.url}app.js") as response:
                 browser_script = await response.text()
@@ -429,6 +450,9 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert 'type: "touch"' in browser_script
                 assert "openFileSelector" in browser_script
                 assert 'type === "file_selector"' in browser_script
+                assert "completeFileSelection" in browser_script
+                assert '"too_large"' in browser_script
+                assert '"disallowed_type"' in browser_script
                 assert (
                     "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`"
                     in browser_script
@@ -436,7 +460,13 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert "input.accept" in browser_script
                 assert "file.size" in browser_script
                 assert 'addEventListener("cancel"' in browser_script
-                assert "Choose file" in browser_page
+                assert "selectedFilePolicyStatus" in browser_script
+                assert "showPromptDialog" in browser_script
+                assert "showModal" not in browser_script
+                assert "The app wants to open a file" in browser_script
+                assert 'label: "Accepted types"' in browser_script
+                assert 'label: "Max size allowed"' in browser_script
+                assert "Choose file" not in browser_page
                 assert "response.ok" in browser_script
 
         window.request_hide_cursor(True)
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index fd976c4be..e0eec1b9e 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -28,9 +28,9 @@ uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 
 Run the file-picker application. Native Linux needs `zenity` or `kdialog`
 (the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
-**Choose file** control in the viewer (the picker must open from a browser
-click). The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Picks larger
-than 32 MiB are rejected in every mode.
+confirmation dialog in the viewer (the picker must open from a browser click).
+The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Failed picks
+show in red with the `SelectedFilesStatus` name and why.
 ```bash
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode native-window
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode webrtc \
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 49cf3ad5d..ecb262d4d 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -3,6 +3,7 @@
 
 """ImGui file-picker application for the v2 loop runtime."""
 
+import math
 import uuid
 from collections.abc import Sequence
 from dataclasses import dataclass
@@ -12,17 +13,77 @@
 from torch import Tensor
 
 from flashdreams.api_v2.application import IApplication
+from flashdreams.api_v2.loop import IModelLoop
 from flashdreams.api_v2.session import ISession
 from flashdreams.runtime_v2.imgui_ui_loop import ImGuiUILoop
 from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     MAX_SELECTED_FILE_BYTES,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
 
-from .text_input_app import BackgroundModelLoop
+_BREATHE_PERIOD_S = 3.0
+"""Seconds for one black → gray → black cycle in the demo background."""
+
+_BREATHE_BLACK = -1.0
+"""Model-frame value for black in ``[-1, 1]``."""
+
+_BREATHE_GRAY = -0.25
+"""Brightest gray in the cycle. Stops short of white."""
+
+_FILE_SELECTION_STATUS_TEXT = {
+    SelectedFilesStatus.CANCELLED: (
+        "SelectedFilesStatus.CANCELLED: user dismissed the selector."
+    ),
+    SelectedFilesStatus.TOO_LARGE: (
+        "SelectedFilesStatus.TOO_LARGE: file exceeded this request's "
+        f"max_bytes={MAX_SELECTED_FILE_BYTES} (32 MiB)."
+    ),
+    SelectedFilesStatus.DISALLOWED_TYPE: (
+        "SelectedFilesStatus.DISALLOWED_TYPE: suffix not in "
+        "accept=('.bin', '.raw')."
+    ),
+    SelectedFilesStatus.UNAVAILABLE: (
+        "SelectedFilesStatus.UNAVAILABLE: picker did not run "
+        "(--mode mp4, dropped WebRTC peer, or unreadable path / OSError)."
+    ),
+}
+_FILE_SELECTION_ERROR_COLOR = (1.0, 0.25, 0.25, 1.0)
+"""RGBA used for cancelled and other failed selector results."""
+
+
+class BreathingBackgroundModelLoop(IModelLoop[tuple[SessionDesc, torch.device | str]]):
+    """Generate a black-to-gray breathing background for the file-picker demo."""
+
+    def step(self, step_index: int, events: UserInputEvents) -> list[StepResult]:
+        """Return one background frame along a 3s black-gray cycle."""
+        del events
+        desc, device = self.state
+        phase = (step_index / desc.frames_per_second_for_step) * (
+            2.0 * math.pi / _BREATHE_PERIOD_S
+        )
+        mix = 0.5 - 0.5 * math.cos(phase)
+        level = _BREATHE_BLACK + (_BREATHE_GRAY - _BREATHE_BLACK) * mix
+        return [
+            StepResult(
+                step_index=step_index,
+                output=torch.full(
+                    (1, 3, desc.video_height, desc.video_width),
+                    level,
+                    dtype=torch.float32,
+                    device=device,
+                ),
+                frame_count=1,
+                output_layout=desc.output_layout,
+            )
+        ]
+
+    def reset(self) -> None:
+        return
 
 
 @dataclass(slots=True)
@@ -47,14 +108,14 @@ def step_ui(
         for event in events.get_events():
             if not isinstance(event, SelectedFilesUserInputEvent):
                 continue
-            if not event.files:
-                self.state.status = "Cancelled."
+            if event.status is not SelectedFilesStatus.OK:
+                self.state.status = _FILE_SELECTION_STATUS_TEXT[event.status]
                 continue
             chosen = event.files[0]
             self.state.status = f"{chosen.name} ({len(chosen.data)} bytes)"
 
         imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
-        imgui.set_next_window_size(imgui.ImVec2(420.0, 130.0), imgui.Cond_.once)
+        imgui.set_next_window_size(imgui.ImVec2(520.0, 180.0), imgui.Cond_.once)
         imgui.begin("File picker")
         try:
             if imgui.button("Open file"):
@@ -63,7 +124,17 @@ def step_ui(
                     accept=(".bin", ".raw"),
                     max_bytes=MAX_SELECTED_FILE_BYTES,
                 )
-            imgui.text(self.state.status)
+            if self.state.status in _FILE_SELECTION_STATUS_TEXT.values():
+                imgui.push_style_color(
+                    imgui.Col_.text,
+                    imgui.ImVec4(*_FILE_SELECTION_ERROR_COLOR),
+                )
+                try:
+                    imgui.text_wrapped(self.state.status)
+                finally:
+                    imgui.pop_style_color()
+            else:
+                imgui.text(self.state.status)
         finally:
             imgui.end()
         return self.presented_model_frame()
@@ -111,7 +182,7 @@ def init(self) -> None:
             height=self._session_desc.video_height,
         )
         self.register_model_loop(
-            BackgroundModelLoop,
+            BreathingBackgroundModelLoop,
             state=(self._session_desc, self._device),
         )
 
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 34fadc745..7c66a98ed 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -9,7 +9,12 @@
 from unittest.mock import Mock
 
 import pytest
-from imgui_ui_demo.file_picker_app import FilePickerImGuiUILoop, FilePickerState
+from imgui_ui_demo.file_picker_app import (
+    FilePickerImGuiUILoop,
+    FilePickerState,
+    _FILE_SELECTION_ERROR_COLOR,
+    _FILE_SELECTION_STATUS_TEXT,
+)
 from imgui_ui_demo.text_input_app import TextInputImGuiUILoop, TextInputState
 from numpy import uint64
 
@@ -18,6 +23,7 @@
 from flashdreams.runtime_v2.user_input_event import (
     MAX_SELECTED_FILE_BYTES,
     SelectedFile,
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
@@ -72,19 +78,28 @@ def _file_picker_loop() -> tuple[FilePickerState, FilePickerImGuiUILoop]:
     return state, loop
 
 
-def test_open_file_button_requests_a_client_file() -> None:
-    _state, loop = _file_picker_loop()
-    imgui = SimpleNamespace(
+def _file_picker_imgui(*, button: bool = False) -> SimpleNamespace:
+    return SimpleNamespace(
         ImVec2=lambda x, y: (x, y),
+        ImVec4=lambda x, y, z, w: (x, y, z, w),
+        Col_=SimpleNamespace(text="text"),
         Cond_=SimpleNamespace(once="once"),
         set_next_window_pos=Mock(),
         set_next_window_size=Mock(),
         begin=Mock(),
         end=Mock(),
         text=Mock(),
-        button=Mock(return_value=True),
+        text_wrapped=Mock(),
+        push_style_color=Mock(),
+        pop_style_color=Mock(),
+        button=Mock(return_value=button),
     )
 
+
+def test_open_file_button_requests_a_client_file() -> None:
+    _state, loop = _file_picker_loop()
+    imgui = _file_picker_imgui(button=True)
+
     loop.step_ui(imgui, 0, UserInputEvents([]))
     requests = loop.flush_ui_loop_requests()
 
@@ -97,16 +112,7 @@ def test_open_file_button_requests_a_client_file() -> None:
 
 def test_selected_files_event_updates_file_picker_status() -> None:
     state, loop = _file_picker_loop()
-    imgui = SimpleNamespace(
-        ImVec2=lambda x, y: (x, y),
-        Cond_=SimpleNamespace(once="once"),
-        set_next_window_pos=Mock(),
-        set_next_window_size=Mock(),
-        begin=Mock(),
-        end=Mock(),
-        text=Mock(),
-        button=Mock(return_value=False),
-    )
+    imgui = _file_picker_imgui()
 
     loop.step_ui(
         imgui,
@@ -116,6 +122,7 @@ def test_selected_files_event_updates_file_picker_status() -> None:
                 SelectedFilesUserInputEvent(
                     timestamp=uint64(0),
                     request_id="open-1",
+                    status=SelectedFilesStatus.OK,
                     files=(SelectedFile(name="seed.png", data=b"xx"),),
                 )
             ]
@@ -124,3 +131,37 @@ def test_selected_files_event_updates_file_picker_status() -> None:
 
     assert state.status == "seed.png (2 bytes)"
     imgui.text.assert_called_with("seed.png (2 bytes)")
+    imgui.text_wrapped.assert_not_called()
+    imgui.push_style_color.assert_not_called()
+
+
+def test_file_picker_shows_error_status_in_red() -> None:
+    assert set(_FILE_SELECTION_STATUS_TEXT) == {
+        status
+        for status in SelectedFilesStatus
+        if status is not SelectedFilesStatus.OK
+    }
+    state, loop = _file_picker_loop()
+    imgui = _file_picker_imgui()
+    cancelled = SelectedFilesStatus.CANCELLED
+
+    loop.step_ui(
+        imgui,
+        0,
+        UserInputEvents(
+            [
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id="open-1",
+                    status=cancelled,
+                )
+            ]
+        ),
+    )
+
+    message = _FILE_SELECTION_STATUS_TEXT[cancelled]
+    assert state.status == message
+    imgui.push_style_color.assert_called_with("text", _FILE_SELECTION_ERROR_COLOR)
+    imgui.text_wrapped.assert_called_with(message)
+    imgui.pop_style_color.assert_called_once_with()
+    imgui.text.assert_not_called()

From 4d9bc78c527a3d517cb8cb611600f8cdabbb5978 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 1 Oct 2026 16:35:06 -0700
Subject: [PATCH 08/43] Complete failed native picks and drop stale WebRTC
 uploads on handoff.

A crashing OS chooser now reports unavailable instead of leaving the request unanswered. WebRTC stamps an internal session epoch so a POST started in the old session cannot become input for the next one.
---
 .../runtime_v2/native_window_client_window.py | 26 +++++----
 .../runtime_v2/serving/webrtc_server.py       | 54 +++++++++++--------
 .../test_native_window_client_window.py       | 25 +++++++++
 .../test_v2/test_webrtc_client_window.py      | 47 ++++++++++++++--
 4 files changed, 117 insertions(+), 35 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 897735eac..97b6f8370 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -337,18 +337,26 @@ def _complete_file_selection(
         max_bytes: int,
     ) -> None:
         """Run the OS picker and enqueue a selected-files event."""
+        files: tuple[SelectedFile, ...] = ()
+        status = SelectedFilesStatus.UNAVAILABLE
         try:
-            selected = _ask_open_filename(initial_dir=initial_dir, accept=accept)
-            if selected:
-                chosen, status = _selected_file_from_path(
-                    Path(selected),
-                    accept=accept,
-                    max_bytes=max_bytes,
+            try:
+                selected = _ask_open_filename(initial_dir=initial_dir, accept=accept)
+            except Exception:
+                _LOGGER.exception(
+                    "Native file picker failed for request id %r.",
+                    request_id,
                 )
-                files: tuple[SelectedFile, ...] = () if chosen is None else (chosen,)
             else:
-                files = ()
-                status = SelectedFilesStatus.CANCELLED
+                if selected:
+                    chosen, status = _selected_file_from_path(
+                        Path(selected),
+                        accept=accept,
+                        max_bytes=max_bytes,
+                    )
+                    files = () if chosen is None else (chosen,)
+                else:
+                    status = SelectedFilesStatus.CANCELLED
             started_ns = self._session_started_ns
             elapsed_ns = (
                 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index db655bb2d..757ac9481 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -312,6 +312,9 @@ class _PendingFileSelection:
     max_bytes: int
     """Maximum file bytes, already clamped to the window ceiling."""
 
+    epoch: int
+    """Session epoch that armed this request; later epochs drop the result."""
+
 
 class WebRTCServer:
     """Own the HTTP, signaling, input buffering, and media transport."""
@@ -368,6 +371,7 @@ def __init__(
         self._queued_file_selectors: list[dict[str, Any]] = []
         self._pending_file_requests: dict[str, _PendingFileSelection] = {}
         self._file_selector_lock = threading.Lock()
+        self._file_selection_epoch = 0
         self._thread = threading.Thread(
             target=self._run_server,
             name="flashdreams-webrtc",
@@ -503,6 +507,7 @@ def _arm_file_selector(self, payload: dict[str, Any]) -> None:
             self._pending_file_requests[request_id] = _PendingFileSelection(
                 accept=tuple(accept),
                 max_bytes=max_bytes,
+                epoch=self._file_selection_epoch,
             )
         self._send_file_selector(payload)
 
@@ -513,6 +518,10 @@ def _take_pending_file_request(
         with self._file_selector_lock:
             return self._pending_file_requests.pop(request_id, None)
 
+    def _file_selection_belongs_to_current_session(self, epoch: int) -> bool:
+        """Return whether ``epoch`` was armed for the open session."""
+        return not self._closed and epoch == self._file_selection_epoch
+
     def _invalidate_file_selectors(self) -> None:
         """Drop queued and pending selector requests without completing them."""
         with self._file_selector_lock:
@@ -612,6 +621,7 @@ def open(self, session_desc: SessionDesc) -> None:
             # Keep timestamps comparable across sessions so events buffered
             # during a handoff retain their real order.
             self._event_origin_ns = time.monotonic_ns()
+        self._file_selection_epoch += 1
         self._invalidate_file_selectors()
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
@@ -893,22 +903,30 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
             raise web.HTTPConflict(
                 reason="No pending file selection for this request_id."
             )
-        try:
-            post = await request.post()
-        except web.HTTPRequestEntityTooLarge:
+
+        def emit(
+            status: SelectedFilesStatus,
+            files: tuple[SelectedFile, ...] = (),
+        ) -> None:
+            if not self._file_selection_belongs_to_current_session(policy.epoch):
+                raise web.HTTPConflict(
+                    reason="No pending file selection for this request_id."
+                )
             self._emit_selected_files(
                 timestamp_us,
                 request_id,
-                status=SelectedFilesStatus.TOO_LARGE,
+                status=status,
+                files=files,
             )
+
+        try:
+            post = await request.post()
+        except web.HTTPRequestEntityTooLarge:
+            emit(SelectedFilesStatus.TOO_LARGE)
             raise
         upload = post.get("file")
         if not isinstance(upload, FileField):
-            self._emit_selected_files(
-                timestamp_us,
-                request_id,
-                status=SelectedFilesStatus.UNAVAILABLE,
-            )
+            emit(SelectedFilesStatus.UNAVAILABLE)
             raise web.HTTPBadRequest(reason="File upload requires a file.")
         data = upload.file.read()
         name = upload.filename or "upload"
@@ -916,26 +934,16 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
             name, len(data), accept=policy.accept, max_bytes=policy.max_bytes
         )
         if rejected is SelectedFilesStatus.DISALLOWED_TYPE:
-            self._emit_selected_files(
-                timestamp_us,
-                request_id,
-                status=rejected,
-            )
+            emit(rejected)
             return web.Response(status=204)
         if rejected is SelectedFilesStatus.TOO_LARGE:
-            self._emit_selected_files(
-                timestamp_us,
-                request_id,
-                status=rejected,
-            )
+            emit(rejected)
             raise web.HTTPRequestEntityTooLarge(
                 max_size=policy.max_bytes,
                 actual_size=len(data),
             )
-        self._emit_selected_files(
-            timestamp_us,
-            request_id,
-            status=SelectedFilesStatus.OK,
+        emit(
+            SelectedFilesStatus.OK,
             files=(SelectedFile(name=name, data=data),),
         )
         return web.Response(status=204)
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 65a232910..5fae67952 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -651,6 +651,31 @@ def test_native_window_reports_cancelled_file_selection(
     assert event.files == ()
 
 
+def test_native_window_reports_unavailable_when_picker_raises(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    def fail_picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+        del initial_dir, accept
+        raise RuntimeError("Native file picker needs a desktop chooser.")
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", fail_picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.UNAVAILABLE
+    assert event.files == ()
+
+
 def test_selected_file_from_path_skips_unreadable_and_oversize(
     tmp_path: Path,
 ) -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index cfe7ce9d8..f4e0a28a9 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -20,7 +20,7 @@
 pytest.importorskip("aiohttp")
 pytest.importorskip("aiortc")
 
-from aiohttp import ClientSession, FormData
+from aiohttp import ClientSession, FormData, web
 from aiortc import (
     MediaStreamTrack,
     RTCDataChannel,
@@ -315,8 +315,7 @@ async def test_file_upload_prefers_disallowed_suffix_over_oversize() -> None:
         window.request_selected_files("open-1", accept=(".png",), max_bytes=1)
         await _wait_file_armed(window, "open-1")
         assert (
-            await _post_selected_file(window, "open-1", b"x" * 8192, "hello.txt")
-            == 204
+            await _post_selected_file(window, "open-1", b"x" * 8192, "hello.txt") == 204
         )
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
@@ -370,6 +369,48 @@ async def test_session_handoff_clears_pending_file_selection() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_in_flight_upload_is_dropped_after_session_handoff(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", "/tmp")
+        await _wait_file_armed(window, "open-1")
+        original_post = web.Request.post
+        handed_off = False
+
+        async def post_after_handoff(request: web.Request) -> Any:
+            nonlocal handed_off
+            if not handed_off:
+                handed_off = True
+                window.open(_session_desc())
+            return await original_post(request)
+
+        monkeypatch.setattr(web.Request, "post", post_after_handoff)
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
+        assert window.get_user_input_events().get_events() == []
+
+        window.request_selected_files("open-1", "/tmp")
+        await _wait_file_armed(window, "open-1")
+        assert await _post_selected_file(window, "open-1", b"next", "next.txt") == 204
+        events = []
+        for _ in range(100):
+            events.extend(window.get_user_input_events().get_events())
+            if events:
+                break
+            await asyncio.sleep(0.01)
+        assert len(events) == 1
+        event = events[0]
+        assert isinstance(event, SelectedFilesUserInputEvent)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.OK
+        assert event.files[0].data == b"next"
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_window_buffers_browser_events_until_drained() -> None:
     window = WebRTCClientWindow()

From a158c5c54f008e6cb91a829ba04621f6f85104e6 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 1 Oct 2026 16:55:23 -0700
Subject: [PATCH 09/43] Fix CPU lint: file-selection request tuple type and
 ruff format.

The fake window recorded accept/max_bytes but was still typed as a 2-tuple, which ty rejected. Also apply the isort/format nits CI auto-fixed.
---
 flashdreams/test_v2/test_session_runner.py                | 4 +++-
 .../imgui_ui_demo/imgui_ui_demo/file_picker_app.py        | 3 +--
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py             | 8 +++-----
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index 40fef46d1..bb319a0ae 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -660,7 +660,9 @@ def __init__(
         self.session_desc: SessionDesc | None = None
         self.results: list[StepResult] = []
         self.cursor_requests: list[tuple[str, bool]] = []
-        self.file_selection_requests: list[tuple[str, str | None]] = []
+        self.file_selection_requests: list[
+            tuple[str, str | None, tuple[str, ...], int | None]
+        ] = []
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Record one cursor visibility request."""
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index ecb262d4d..33409b1c6 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -44,8 +44,7 @@
         f"max_bytes={MAX_SELECTED_FILE_BYTES} (32 MiB)."
     ),
     SelectedFilesStatus.DISALLOWED_TYPE: (
-        "SelectedFilesStatus.DISALLOWED_TYPE: suffix not in "
-        "accept=('.bin', '.raw')."
+        "SelectedFilesStatus.DISALLOWED_TYPE: suffix not in accept=('.bin', '.raw')."
     ),
     SelectedFilesStatus.UNAVAILABLE: (
         "SelectedFilesStatus.UNAVAILABLE: picker did not run "
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 7c66a98ed..727cf149c 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -10,10 +10,10 @@
 
 import pytest
 from imgui_ui_demo.file_picker_app import (
-    FilePickerImGuiUILoop,
-    FilePickerState,
     _FILE_SELECTION_ERROR_COLOR,
     _FILE_SELECTION_STATUS_TEXT,
+    FilePickerImGuiUILoop,
+    FilePickerState,
 )
 from imgui_ui_demo.text_input_app import TextInputImGuiUILoop, TextInputState
 from numpy import uint64
@@ -137,9 +137,7 @@ def test_selected_files_event_updates_file_picker_status() -> None:
 
 def test_file_picker_shows_error_status_in_red() -> None:
     assert set(_FILE_SELECTION_STATUS_TEXT) == {
-        status
-        for status in SelectedFilesStatus
-        if status is not SelectedFilesStatus.OK
+        status for status in SelectedFilesStatus if status is not SelectedFilesStatus.OK
     }
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()

From 1f7f06a0403b98b73a9a644392f449edf13aa2c5 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 10:39:21 -0700
Subject: [PATCH 10/43] Serve client file picks one at a time with a stable
 request_id per control.

Same id while a pick is active or queued is ignored so mash does not stack dialogs. Distinct ids wait in order. Apps reuse the control's id after the matching event; a new id on every click queues another dialog.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  7 +-
 .../flashdreams/api_v2/client_window.py       | 10 +-
 flashdreams/flashdreams/api_v2/loop.py        | 11 ++-
 .../runtime_v2/file_selection_gate.py         | 98 +++++++++++++++++++
 .../runtime_v2/mp4_client_window.py           | 29 ++++--
 .../runtime_v2/native_window_client_window.py | 51 ++++++----
 .../runtime_v2/null_client_window.py          | 66 ++++++++++++-
 .../flashdreams/runtime_v2/serving/web/app.js | 19 +++-
 .../runtime_v2/serving/webrtc_server.py       |  2 +-
 .../runtime_v2/user_input_event.py            |  2 +-
 .../runtime_v2/webrtc_client_window.py        | 49 ++++++----
 .../test_native_window_client_window.py       | 80 +++++++++++++++
 flashdreams/test_v2/test_selected_files.py    | 85 ++++++++++++++++
 .../test_v2/test_webrtc_client_window.py      | 39 ++++++++
 integrations_v2/imgui_ui_demo/README.md       |  6 +-
 .../imgui_ui_demo/file_picker_app.py          | 41 ++++++--
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py | 46 ++++++++-
 17 files changed, 568 insertions(+), 73 deletions(-)
 create mode 100644 flashdreams/flashdreams/runtime_v2/file_selection_gate.py

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 3cdcb7d40..86243cb35 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -232,7 +232,12 @@ with `selected_file_policy_status` (type before size) and clamp size to 32 MiB
 so a client cannot raise the cap. Empty ``accept`` (the default) allows any
 type; omit ``max_bytes`` to use the 32 MiB ceiling. Read ``status`` for the
 outcome (`ok`, `cancelled`, `too_large`, `disallowed_type`, `unavailable`);
-``files`` is non-empty only on `ok`.
+``files`` is non-empty only on `ok`. Give each UI control a stable
+`request_id` and reuse it after the matching event: extra clicks on that
+control while a picker is opening are ignored. A new id on every click is
+a new control and queues another dialog. Distinct controls use distinct
+ids and are served one client dialog at a time.
+
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
 [`slangpy_ui_demo` integration](../../../integrations_v2/slangpy_ui_demo/README.md)
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 67f65f7ee..cd8a2653b 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -66,10 +66,16 @@ def request_selected_files(
         (type before size) and clamp size to the 32 MiB ceiling. The event
         carries a ``status`` so cancel, oversize, and disallowed type are
         distinct. Applications read that ``status``; they do not re-check type
-        or size.
+        or size. A second call with the same ``request_id`` while the first is
+        still active or queued is ignored. Use one stable id per UI control so
+        extra clicks while the picker is opening do not enqueue more dialogs.
+        A new id on every click is a new control and queues another dialog.
+        A different ``request_id`` waits until the active selector completes,
+        so two controls still run one dialog at a time.
 
         Args:
-            request_id: Correlation token for the later input event.
+            request_id: Stable id for this selector slot, typically one per
+                UI control. Reuse it after the matching event arrives.
             initial_path: Directory the selector should start in; ``None`` lets
                 the window choose a default.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 0b07ab2a4..37df84873 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -82,7 +82,7 @@ class FileSelectionRequest:
     """One client file-selector request queued by a UI loop."""
 
     request_id: str
-    """Correlation token for the later selected-files input event."""
+    """Stable selector-slot id from the UI control that asked for a file."""
 
     initial_path: str
     """Directory the selector should start in."""
@@ -559,7 +559,11 @@ def request_selected_files(
         Read ``status`` for cancel, oversize, disallowed type, or unavailable;
         ``files`` is non-empty only when the pick succeeded. A second call with
         the same ``request_id`` while the first is still queued is ignored so
-        the original picker can still complete.
+        the original picker can still complete. Distinct ids are forwarded in
+        order; the window shows one client selector at a time. Use one stable
+        ``request_id`` per UI control so extra clicks while the picker is
+        opening are ignored; two controls use two ids and are served in order.
+        A new id on every click is a new control and queues another dialog.
 
         ``accept`` and ``max_bytes`` are the application's policy. Windows
         classify the choice with
@@ -568,7 +572,8 @@ def request_selected_files(
         client cannot raise the cap.
 
         Args:
-            request_id: Correlation token for the later input event.
+            request_id: Stable id for this selector slot, typically one per
+                UI control. Reuse it after the matching event arrives.
             initial_path: Directory the selector should start in; ``None`` uses
                 the current user's home directory.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
new file mode 100644
index 000000000..5fea57b41
--- /dev/null
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""One-at-a-time client file-selector queue shared by every window."""
+
+from __future__ import annotations
+
+import logging
+import threading
+from collections import deque
+from dataclasses import dataclass
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class QueuedFileSelection:
+    """One file-selector request waiting to occupy the client dialog."""
+
+    request_id: str
+    """Stable selector-slot id for the later selected-files input event."""
+
+    initial_path: str | None
+    """Directory hint for the selector, or ``None`` for the window default."""
+
+    accept: tuple[str, ...]
+    """Filename suffixes the client may choose, empty for any type."""
+
+    max_bytes: int | None
+    """Requested size budget in bytes, or ``None`` for the window ceiling."""
+
+
+class FileSelectionGate:
+    """Admit one client file selector at a time.
+
+    A duplicate ``request_id`` that is already active or queued is ignored.
+    A different id waits until :meth:`complete` for the active request.
+    """
+
+    def __init__(self) -> None:
+        """Create an empty gate."""
+        self._lock = threading.Lock()
+        self._active: QueuedFileSelection | None = None
+        self._queued: deque[QueuedFileSelection] = deque()
+
+    def submit(self, pending: QueuedFileSelection) -> QueuedFileSelection | None:
+        """Record ``pending`` and return it when it should start now.
+
+        Args:
+            pending: Request the window wants to show.
+
+        Returns:
+            ``pending`` when no selector is active, otherwise ``None`` when the
+            id is a duplicate or the request was queued behind the active one.
+        """
+        with self._lock:
+            if self._contains(pending.request_id):
+                _LOGGER.warning(
+                    "Ignoring duplicate file-selection request id %r.",
+                    pending.request_id,
+                )
+                return None
+            if self._active is None:
+                self._active = pending
+                return pending
+            self._queued.append(pending)
+            return None
+
+    def complete(self, request_id: str) -> QueuedFileSelection | None:
+        """Release ``request_id`` and return the next request to start.
+
+        Args:
+            request_id: Id of the selector that just emitted an event.
+
+        Returns:
+            The next queued request, or ``None`` when this id was not active or
+            the queue is empty.
+        """
+        with self._lock:
+            if self._active is None or self._active.request_id != request_id:
+                return None
+            self._active = None
+            if not self._queued:
+                return None
+            nxt = self._queued.popleft()
+            self._active = nxt
+            return nxt
+
+    def clear(self) -> None:
+        """Drop the active request and every queued request."""
+        with self._lock:
+            self._active = None
+            self._queued.clear()
+
+    def _contains(self, request_id: str) -> bool:
+        if self._active is not None and self._active.request_id == request_id:
+            return True
+        return any(item.request_id == request_id for item in self._queued)
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index 5fa892c48..c02599995 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -9,6 +9,10 @@
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.runtime_v2.file_selection_gate import (
+    FileSelectionGate,
+    QueuedFileSelection,
+)
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
@@ -39,6 +43,7 @@ def __init__(self, path: str | Path) -> None:
         self._path = Path(path)
         self._video_sink = Mp4OutputSink(path)
         self._pending_events: list[UserInputEvent] = []
+        self._file_gate = FileSelectionGate()
 
     @property
     def path(self) -> Path:
@@ -61,20 +66,31 @@ def request_selected_files(
     ) -> None:
         """Complete a file-selector request as unavailable.
 
+        Overlapping distinct ids are completed in order, each as unavailable.
+
         Args:
-            request_id: Correlation token from the UI loop.
+            request_id: Stable selector-slot id from the UI control.
             initial_path: Ignored; this window has no selector.
             accept: Ignored; this window has no selector.
             max_bytes: Ignored; this window has no selector.
         """
-        del initial_path, accept, max_bytes
-        self._pending_events.append(
-            SelectedFilesUserInputEvent(
-                timestamp=uint64(0),
+        started = self._file_gate.submit(
+            QueuedFileSelection(
                 request_id=request_id,
-                status=SelectedFilesStatus.UNAVAILABLE,
+                initial_path=initial_path,
+                accept=tuple(accept),
+                max_bytes=max_bytes,
             )
         )
+        while started is not None:
+            self._pending_events.append(
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=started.request_id,
+                    status=SelectedFilesStatus.UNAVAILABLE,
+                )
+            )
+            started = self._file_gate.complete(started.request_id)
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the MP4 presentation dimensions without replacing the session.
@@ -100,3 +116,4 @@ def write(self, result: StepResult) -> None:
     def close(self) -> None:
         """Finish the MP4 file."""
         self._video_sink.close()
+        self._file_gate.clear()
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 97b6f8370..f7b159ef4 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -25,6 +25,10 @@
 
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.user_input_event import UserInputEvent
+from flashdreams.runtime_v2.file_selection_gate import (
+    FileSelectionGate,
+    QueuedFileSelection,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
@@ -246,8 +250,7 @@ def __init__(
         self._pressed_key_values: dict[str, str] = {}
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._in_flight_file_requests: set[str] = set()
-        self._file_request_lock = threading.Lock()
+        self._file_gate = FileSelectionGate()
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the native window."""
@@ -297,32 +300,38 @@ def request_selected_files(
         """Ask the OS file selector and enqueue the chosen file.
 
         The desktop dialog runs on a worker thread so the UI loop can keep
-        polling and presenting while the picker is open.
+        polling and presenting while the picker is open. A second distinct
+        ``request_id`` waits until this picker completes.
 
         Args:
-            request_id: Correlation token for the later input event.
+            request_id: Stable selector-slot id from the UI control.
             initial_path: Directory the selector should start in; ``None`` uses
                 the current user's home directory.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
         """
-        suffixes = normalize_selected_file_accept(accept)
-        budget = clamp_selected_file_max_bytes(max_bytes)
-        with self._file_request_lock:
-            if request_id in self._in_flight_file_requests:
-                _LOGGER.warning(
-                    "Ignoring duplicate file-selection request id %r.",
-                    request_id,
-                )
-                return
-            self._in_flight_file_requests.add(request_id)
+        started = self._file_gate.submit(
+            QueuedFileSelection(
+                request_id=request_id,
+                initial_path=initial_path or str(Path.home()),
+                accept=normalize_selected_file_accept(accept),
+                max_bytes=clamp_selected_file_max_bytes(max_bytes),
+            )
+        )
+        if started is not None:
+            self._spawn_file_picker(started)
+
+    def _spawn_file_picker(self, pending: QueuedFileSelection) -> None:
+        """Run one OS picker on a worker thread."""
         worker = threading.Thread(
             target=self._complete_file_selection,
             args=(
-                request_id,
-                initial_path or str(Path.home()),
-                suffixes,
-                budget,
+                pending.request_id,
+                pending.initial_path or str(Path.home()),
+                pending.accept,
+                pending.max_bytes
+                if pending.max_bytes is not None
+                else MAX_SELECTED_FILE_BYTES,
             ),
             name="flashdreams-file-picker",
             daemon=True,
@@ -370,8 +379,9 @@ def _complete_file_selection(
                 )
             )
         finally:
-            with self._file_request_lock:
-                self._in_flight_file_requests.discard(request_id)
+            nxt = self._file_gate.complete(request_id)
+            if nxt is not None and self._presenter is not None:
+                self._spawn_file_picker(nxt)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Create the GLFW window on the runtime's UI thread.
@@ -492,6 +502,7 @@ def write(self, result: StepResult) -> None:
 
     def close(self) -> None:
         """Release SlangPy and the GLFW window on the runtime's UI thread."""
+        self._file_gate.clear()
         presenter = self._presenter
         self._presenter = None
         self._session_started_ns = None
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index 76ff107fa..8fdd80680 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -3,18 +3,76 @@
 
 """Client window that discards output and reports no input."""
 
+from collections.abc import Sequence
+
+from numpy import uint64
+
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.runtime_v2.file_selection_gate import (
+    FileSelectionGate,
+    QueuedFileSelection,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_event import (
+    SelectedFilesStatus,
+    SelectedFilesUserInputEvent,
+    UserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
 class NullClientWindow(IClientWindow):
-    """Discard output and report no input."""
+    """Discard output and report no input.
+
+    File-selector requests complete immediately as unavailable. This window
+    has no interactive client.
+    """
+
+    def __init__(self) -> None:
+        """Create a window that drops output."""
+        self._pending_events: list[UserInputEvent] = []
+        self._file_gate = FileSelectionGate()
 
     def get_user_input_events(self) -> UserInputEvents:
-        """Return an empty input batch."""
-        return UserInputEvents([])
+        """Return file-selector results queued since the previous poll."""
+        events = self._pending_events
+        self._pending_events = []
+        return UserInputEvents(events)
+
+    def request_selected_files(
+        self,
+        request_id: str,
+        initial_path: str | None = None,
+        *,
+        accept: Sequence[str] = (),
+        max_bytes: int | None = None,
+    ) -> None:
+        """Complete a file-selector request as unavailable.
+
+        Args:
+            request_id: Stable selector-slot id from the UI control.
+            initial_path: Ignored; this window has no selector.
+            accept: Ignored; this window has no selector.
+            max_bytes: Ignored; this window has no selector.
+        """
+        started = self._file_gate.submit(
+            QueuedFileSelection(
+                request_id=request_id,
+                initial_path=initial_path,
+                accept=tuple(accept),
+                max_bytes=max_bytes,
+            )
+        )
+        while started is not None:
+            self._pending_events.append(
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=started.request_id,
+                    status=SelectedFilesStatus.UNAVAILABLE,
+                )
+            )
+            started = self._file_gate.complete(started.request_id)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Accept a session without opening an output."""
@@ -26,4 +84,4 @@ def write(self, result: StepResult) -> None:
 
     def close(self) -> None:
         """Close without releasing any resources."""
-        return
+        self._file_gate.clear()
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 7f1e099b7..ad7c572d3 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -212,6 +212,7 @@ if (promptBackdrop !== null) {
 }
 
 let pendingFileRequest = null;
+let queuedFileSelectors = [];
 
 const hideFilePicker = () => {
   pendingFileRequest = null;
@@ -221,6 +222,12 @@ const hideFilePicker = () => {
     promptOnCancel = null;
     closePromptDialog();
   }
+  const next = queuedFileSelectors.shift();
+  if (next !== undefined) {
+    // The runtime may arm the next selector before this viewer's fetch
+    // callback runs; show it after the current dialog has fully settled.
+    window.queueMicrotask(() => openFileSelector(next));
+  }
 };
 
 const completeFileSelection = (requestId, status) => {
@@ -325,8 +332,14 @@ const openFileSelector = options => {
   if (typeof requestId !== "string" || !requestId) {
     return;
   }
-  if (pendingFileRequest !== null && pendingFileRequest.id !== requestId) {
-    completeFileSelection(pendingFileRequest.id, "cancelled");
+  if (pendingFileRequest !== null) {
+    if (
+      pendingFileRequest.id !== requestId
+      && queuedFileSelectors.every(item => item.id !== requestId)
+    ) {
+      queuedFileSelectors.push(options);
+    }
+    return;
   }
   const accept = Array.isArray(options.accept) ? options.accept : [];
   const maxBytes = Number(options.max_bytes);
@@ -360,7 +373,7 @@ const openFileSelector = options => {
         return;
       }
       completeFileSelection(requestId, "cancelled");
-      pendingFileRequest = null;
+      hideFilePicker();
     },
   });
 };
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 757ac9481..b5675ea57 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -473,7 +473,7 @@ def request_selected_files(
         """Ask the connected browser to open a file selector.
 
         Args:
-            request_id: Correlation token for the later input event.
+            request_id: Stable selector-slot id from the UI control.
             initial_path: Ignored; the browser picker cannot use a host path.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 203839452..68c3d196d 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -315,7 +315,7 @@ class SelectedFilesStatus(Enum):
     """The chosen file did not match ``accept``. Checked before size."""
 
     UNAVAILABLE = "unavailable"
-    """No picker could run: ``--mode mp4``, a dropped peer, or an unreadable file."""
+    """No picker could run: headless output, a dropped peer, or an unreadable file."""
 
 
 def selected_file_policy_status(
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 8b7026611..4e48080cf 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -3,7 +3,6 @@
 
 """WebRTC client window for the v2 runtime."""
 
-import logging
 import threading
 from collections import deque
 from collections.abc import Sequence
@@ -12,17 +11,20 @@
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.runtime_v2.file_selection_gate import (
+    FileSelectionGate,
+    QueuedFileSelection,
+)
 from flashdreams.runtime_v2.serving.webrtc_server import WebRTCServer
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     SelectedFilesUserInputEvent,
     UserInputEvent,
+    normalize_selected_file_accept,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class WebRTCClientWindow(IClientWindow):
     """Client window streaming a run to a browser.
@@ -62,7 +64,7 @@ def __init__(
         self._input_events: deque[UserInputEvent] = deque()
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._in_flight_file_requests: set[str] = set()
+        self._file_gate = FileSelectionGate()
         self._input_lock = threading.Lock()
         # Offset from the server's stable clock to the current session's clock.
         self._session_event_offset_us = uint64(0)
@@ -75,10 +77,13 @@ def __init__(
         def handle_input(event: UserInputEvent) -> None:
             """Buffer one backend event for the ``InputSource`` protocol."""
             # TODO: do we really need to buffer all events? Some mouse moves may be superseded by later ones.
+            nxt = None
             with self._input_lock:
                 if isinstance(event, SelectedFilesUserInputEvent):
-                    self._in_flight_file_requests.discard(event.request_id)
+                    nxt = self._file_gate.complete(event.request_id)
                 self._input_events.append(event)
+            if nxt is not None:
+                self._start_file_selection(nxt)
 
         self.server.register_input_callback(handle_input)
 
@@ -120,25 +125,34 @@ def request_selected_files(
     ) -> None:
         """Ask the connected browser to open a file selector.
 
+        A second distinct ``request_id`` waits until the active selector
+        completes so the viewer shows one dialog at a time.
+
         Args:
-            request_id: Correlation token for the later input event.
+            request_id: Stable selector-slot id from the UI control.
             initial_path: Ignored by the browser picker; kept so the window
                 signature matches :meth:`IClientWindow.request_selected_files`.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
         """
-        if request_id in self._in_flight_file_requests:
-            _LOGGER.warning(
-                "Ignoring duplicate file-selection request id %r.",
-                request_id,
+        started = self._file_gate.submit(
+            QueuedFileSelection(
+                request_id=request_id,
+                initial_path=initial_path,
+                accept=normalize_selected_file_accept(accept),
+                max_bytes=max_bytes,
             )
-            return
-        self._in_flight_file_requests.add(request_id)
+        )
+        if started is not None:
+            self._start_file_selection(started)
+
+    def _start_file_selection(self, pending: QueuedFileSelection) -> None:
+        """Arm the WebRTC server for one file-selector request."""
         self.server.request_selected_files(
-            request_id,
-            initial_path=initial_path,
-            accept=accept,
-            max_bytes=max_bytes,
+            pending.request_id,
+            initial_path=pending.initial_path,
+            accept=pending.accept,
+            max_bytes=pending.max_bytes,
         )
 
     def open(self, session_desc: SessionDesc) -> None:
@@ -151,7 +165,7 @@ def open(self, session_desc: SessionDesc) -> None:
         session_event_offset_us = self.server.event_timestamp_us()
         with self._input_lock:
             self._input_events.clear()
-            self._in_flight_file_requests.clear()
+            self._file_gate.clear()
             self._session_event_offset_us = session_event_offset_us
 
     def get_user_input_events(self) -> UserInputEvents:
@@ -193,4 +207,5 @@ def metrics_snapshot(self) -> dict[str, float | int]:
 
     def close(self) -> None:
         """Implement ``OutputSink.close`` by releasing WebRTC resources."""
+        self._file_gate.clear()
         self.server.close()
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 5fae67952..de9f854e0 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -676,6 +676,86 @@ def fail_picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     assert event.files == ()
 
 
+def test_native_window_serves_one_file_selection_at_a_time(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    first_entered = threading.Event()
+    first_released = threading.Event()
+    calls: list[tuple[str, ...]] = []
+
+    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+        del initial_dir
+        calls.append(accept)
+        if len(calls) == 1:
+            first_entered.set()
+            assert first_released.wait(timeout=2.0)
+        return ""
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path), accept=(".bin",))
+    assert first_entered.wait(timeout=2.0)
+    window.request_selected_files("open-2", str(tmp_path), accept=(".raw",))
+    assert calls == [(".bin",)]
+    first_released.set()
+    events = []
+    for _ in range(200):
+        events.extend(window.get_user_input_events().get_events())
+        if len(events) >= 2:
+            break
+        time.sleep(0.01)
+    window.close()
+
+    assert [event.request_id for event in events] == ["open-1", "open-2"]
+    assert all(
+        isinstance(event, SelectedFilesUserInputEvent)
+        and event.status is SelectedFilesStatus.CANCELLED
+        for event in events
+    )
+    assert calls == [(".bin",), (".raw",)]
+
+
+def test_native_window_ignores_duplicate_in_flight_file_selection_id(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    released = threading.Event()
+    entered = threading.Event()
+    calls: list[int] = []
+
+    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+        del initial_dir, accept
+        calls.append(1)
+        entered.set()
+        if len(calls) == 1:
+            assert released.wait(timeout=2.0)
+        return ""
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    assert entered.wait(timeout=2.0)
+    window.request_selected_files("open-1", str(tmp_path))
+    time.sleep(0.05)
+    assert calls == [1]
+    released.set()
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.CANCELLED
+
+
 def test_selected_file_from_path_skips_unreadable_and_oversize(
     tmp_path: Path,
 ) -> None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index b24d85f10..c07227f4c 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -11,7 +11,12 @@
 from numpy import uint64
 
 from flashdreams.api_v2.loop import IUILoop
+from flashdreams.runtime_v2.file_selection_gate import (
+    FileSelectionGate,
+    QueuedFileSelection,
+)
 from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
+from flashdreams.runtime_v2.null_client_window import NullClientWindow
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
@@ -88,6 +93,52 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     assert selection.max_bytes == MAX_SELECTED_FILE_BYTES * 2
 
 
+def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
+    loop = _ui_loop()
+    loop.request_selected_files("open-1", "/tmp")
+    loop.request_selected_files("open-2", "/var")
+
+    requests = loop.flush_ui_loop_requests()
+    assert requests is not None
+    assert [item.request_id for item in requests.file_selections] == [
+        "open-1",
+        "open-2",
+    ]
+
+
+def _queued(request_id: str) -> QueuedFileSelection:
+    return QueuedFileSelection(
+        request_id=request_id,
+        initial_path="/tmp",
+        accept=(".bin",),
+        max_bytes=16,
+    )
+
+
+def test_file_selection_gate_ignores_duplicates_and_serves_one_at_a_time() -> None:
+    gate = FileSelectionGate()
+    assert gate.submit(_queued("open-1")) is not None
+    assert gate.submit(_queued("open-1")) is None
+    assert gate.submit(_queued("open-2")) is None
+    assert gate.submit(_queued("open-2")) is None
+    assert gate.complete("open-2") is None
+    nxt = gate.complete("open-1")
+    assert nxt is not None
+    assert nxt.request_id == "open-2"
+    assert gate.complete("open-2") is None
+
+
+def test_file_selection_gate_clear_drops_queued_requests() -> None:
+    gate = FileSelectionGate()
+    assert gate.submit(_queued("open-1")) is not None
+    assert gate.submit(_queued("open-2")) is None
+    gate.clear()
+    assert gate.complete("open-1") is None
+    started = gate.submit(_queued("open-2"))
+    assert started is not None
+    assert started.request_id == "open-2"
+
+
 def test_selected_file_policy_helpers() -> None:
     assert clamp_selected_file_max_bytes(None) == MAX_SELECTED_FILE_BYTES
     assert clamp_selected_file_max_bytes(16) == 16
@@ -147,3 +198,37 @@ def test_mp4_window_completes_file_selection_as_unavailable(tmp_path: Path) -> N
     assert event.status is SelectedFilesStatus.UNAVAILABLE
     assert event.files == ()
     assert window.get_user_input_events().get_events() == []
+
+
+def test_mp4_window_completes_queued_file_selections_as_unavailable(
+    tmp_path: Path,
+) -> None:
+    window = Mp4ClientWindow(tmp_path / "clip.mp4")
+    window.request_selected_files("open-1", "/tmp")
+    window.request_selected_files("open-2", "/var")
+
+    events = window.get_user_input_events().get_events()
+
+    assert [event.request_id for event in events] == ["open-1", "open-2"]
+    assert all(
+        isinstance(event, SelectedFilesUserInputEvent)
+        and event.status is SelectedFilesStatus.UNAVAILABLE
+        and event.files == ()
+        for event in events
+    )
+
+
+def test_null_window_completes_file_selection_as_unavailable() -> None:
+    window = NullClientWindow()
+    window.request_selected_files("open-1", "/tmp")
+    window.request_selected_files("open-2", "/var")
+
+    events = window.get_user_input_events().get_events()
+
+    assert [event.request_id for event in events] == ["open-1", "open-2"]
+    assert all(
+        isinstance(event, SelectedFilesUserInputEvent)
+        and event.status is SelectedFilesStatus.UNAVAILABLE
+        and event.files == ()
+        for event in events
+    )
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index f4e0a28a9..7ef2a415d 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -202,6 +202,40 @@ async def test_browser_file_upload_reaches_the_input_stream() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_browser_file_selections_are_served_one_at_a_time() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files("open-2", "/tmp")
+        await _wait_file_armed(window, "open-1")
+        assert "open-2" not in window.server._pending_file_requests
+        assert await _post_selected_file(window, "open-2", b"early", "early.txt") == 409
+        assert await _post_selected_file(window, "open-1", b"first", "first.txt") == 204
+        await _wait_file_armed(window, "open-2")
+        assert (
+            await _post_selected_file(window, "open-2", b"second", "second.txt") == 204
+        )
+
+        events = []
+        for _ in range(100):
+            events.extend(window.get_user_input_events().get_events())
+            if len(events) >= 2:
+                break
+            await asyncio.sleep(0.01)
+        assert [event.request_id for event in events] == ["open-1", "open-2"]
+        assert all(
+            isinstance(event, SelectedFilesUserInputEvent)
+            and event.status is SelectedFilesStatus.OK
+            for event in events
+        )
+        assert events[0].files[0].data == b"first"
+        assert events[1].files[0].data == b"second"
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_unsolicited_file_upload_is_rejected() -> None:
     window = WebRTCClientWindow()
@@ -492,6 +526,11 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert "openFileSelector" in browser_script
                 assert 'type === "file_selector"' in browser_script
                 assert "completeFileSelection" in browser_script
+                assert (
+                    'completeFileSelection(pendingFileRequest.id, "cancelled")'
+                    not in browser_script
+                )
+                assert "queuedFileSelectors" in browser_script
                 assert '"too_large"' in browser_script
                 assert '"disallowed_type"' in browser_script
                 assert (
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index e0eec1b9e..cc6f4ee41 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -10,6 +10,9 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
 - `imgui-ui-text-input` renders an editable text field over model output.
 - `imgui-ui-file-picker` opens the client file selector and shows the chosen
   name and size (the file bytes are on the event; apps should use those).
+  Each Open control uses a stable `request_id`. Extra clicks on the same
+  control while a picker is open are ignored; **Open A then B** queues both
+  selectors one at a time.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.
@@ -29,7 +32,8 @@ uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 Run the file-picker application. Native Linux needs `zenity` or `kdialog`
 (the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
 confirmation dialog in the viewer (the picker must open from a browser click).
-The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Failed picks
+The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Controls are
+**Open file (A)**, **Open file (B)**, and **Open A then B**. Failed picks
 show in red with the `SelectedFilesStatus` name and why.
 ```bash
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode native-window
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 33409b1c6..19763c24e 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -4,7 +4,6 @@
 """ImGui file-picker application for the v2 loop runtime."""
 
 import math
-import uuid
 from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Any
@@ -48,12 +47,27 @@
     ),
     SelectedFilesStatus.UNAVAILABLE: (
         "SelectedFilesStatus.UNAVAILABLE: picker did not run "
-        "(--mode mp4, dropped WebRTC peer, or unreadable path / OSError)."
+        "(--mode mp4 or null, dropped WebRTC peer, or unreadable path / OSError)."
     ),
 }
 _FILE_SELECTION_ERROR_COLOR = (1.0, 0.25, 0.25, 1.0)
 """RGBA used for cancelled and other failed selector results."""
 
+_OPEN_FILE_A_REQUEST_ID = "open-file-a"
+"""Selector slot for Open file (A). Mash uses this same id."""
+
+_OPEN_FILE_B_REQUEST_ID = "open-file-b"
+"""Selector slot for Open file (B). Queued behind A when both are requested."""
+
+_OPEN_FILE_A_LABEL = "Open file (A)"
+"""ImGui label for selector slot A."""
+
+_OPEN_FILE_B_LABEL = "Open file (B)"
+"""ImGui label for selector slot B."""
+
+_OPEN_A_THEN_B_LABEL = "Open A then B"
+"""ImGui label that requests A then B in the same UI tick."""
+
 
 class BreathingBackgroundModelLoop(IModelLoop[tuple[SessionDesc, torch.device | str]]):
     """Generate a black-to-gray breathing background for the file-picker demo."""
@@ -114,15 +128,16 @@ def step_ui(
             self.state.status = f"{chosen.name} ({len(chosen.data)} bytes)"
 
         imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
-        imgui.set_next_window_size(imgui.ImVec2(520.0, 180.0), imgui.Cond_.once)
+        imgui.set_next_window_size(imgui.ImVec2(520.0, 260.0), imgui.Cond_.once)
         imgui.begin("File picker")
         try:
-            if imgui.button("Open file"):
-                self.request_selected_files(
-                    uuid.uuid4().hex,
-                    accept=(".bin", ".raw"),
-                    max_bytes=MAX_SELECTED_FILE_BYTES,
-                )
+            if imgui.button(_OPEN_FILE_A_LABEL):
+                self._request_demo_file(_OPEN_FILE_A_REQUEST_ID)
+            if imgui.button(_OPEN_FILE_B_LABEL):
+                self._request_demo_file(_OPEN_FILE_B_REQUEST_ID)
+            if imgui.button(_OPEN_A_THEN_B_LABEL):
+                self._request_demo_file(_OPEN_FILE_A_REQUEST_ID)
+                self._request_demo_file(_OPEN_FILE_B_REQUEST_ID)
             if self.state.status in _FILE_SELECTION_STATUS_TEXT.values():
                 imgui.push_style_color(
                     imgui.Col_.text,
@@ -138,6 +153,14 @@ def step_ui(
             imgui.end()
         return self.presented_model_frame()
 
+    def _request_demo_file(self, request_id: str) -> None:
+        """Ask for a ``.bin`` / ``.raw`` pick on one selector slot."""
+        self.request_selected_files(
+            request_id,
+            accept=(".bin", ".raw"),
+            max_bytes=MAX_SELECTED_FILE_BYTES,
+        )
+
     def reset(self) -> None:
         """Clear the last selector result for a new generation."""
         self.state.status = "No file selected."
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 727cf149c..b28283623 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -12,6 +12,11 @@
 from imgui_ui_demo.file_picker_app import (
     _FILE_SELECTION_ERROR_COLOR,
     _FILE_SELECTION_STATUS_TEXT,
+    _OPEN_A_THEN_B_LABEL,
+    _OPEN_FILE_A_LABEL,
+    _OPEN_FILE_A_REQUEST_ID,
+    _OPEN_FILE_B_LABEL,
+    _OPEN_FILE_B_REQUEST_ID,
     FilePickerImGuiUILoop,
     FilePickerState,
 )
@@ -78,7 +83,8 @@ def _file_picker_loop() -> tuple[FilePickerState, FilePickerImGuiUILoop]:
     return state, loop
 
 
-def _file_picker_imgui(*, button: bool = False) -> SimpleNamespace:
+def _file_picker_imgui(*, pressed: str | tuple[str, ...] = ()) -> SimpleNamespace:
+    labels = (pressed,) if isinstance(pressed, str) else pressed
     return SimpleNamespace(
         ImVec2=lambda x, y: (x, y),
         ImVec4=lambda x, y, z, w: (x, y, z, w),
@@ -92,24 +98,54 @@ def _file_picker_imgui(*, button: bool = False) -> SimpleNamespace:
         text_wrapped=Mock(),
         push_style_color=Mock(),
         pop_style_color=Mock(),
-        button=Mock(return_value=button),
+        button=Mock(side_effect=lambda label: label in labels),
     )
 
 
 def test_open_file_button_requests_a_client_file() -> None:
     _state, loop = _file_picker_loop()
-    imgui = _file_picker_imgui(button=True)
+    imgui = _file_picker_imgui(pressed=_OPEN_FILE_A_LABEL)
 
     loop.step_ui(imgui, 0, UserInputEvents([]))
+    loop.step_ui(imgui, 1, UserInputEvents([]))
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None
-    assert len(requests.file_selections) == 1
-    assert requests.file_selections[0].request_id
+    assert [item.request_id for item in requests.file_selections] == [
+        _OPEN_FILE_A_REQUEST_ID
+    ]
     assert requests.file_selections[0].accept == (".bin", ".raw")
     assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
 
 
+def test_open_a_then_b_queues_both_request_ids() -> None:
+    _state, loop = _file_picker_loop()
+    imgui = _file_picker_imgui(pressed=_OPEN_A_THEN_B_LABEL)
+
+    loop.step_ui(imgui, 0, UserInputEvents([]))
+    requests = loop.flush_ui_loop_requests()
+
+    assert requests is not None
+    assert [item.request_id for item in requests.file_selections] == [
+        _OPEN_FILE_A_REQUEST_ID,
+        _OPEN_FILE_B_REQUEST_ID,
+    ]
+
+
+def test_two_file_buttons_queue_distinct_request_ids() -> None:
+    _state, loop = _file_picker_loop()
+    imgui = _file_picker_imgui(pressed=(_OPEN_FILE_A_LABEL, _OPEN_FILE_B_LABEL))
+
+    loop.step_ui(imgui, 0, UserInputEvents([]))
+    requests = loop.flush_ui_loop_requests()
+
+    assert requests is not None
+    assert [item.request_id for item in requests.file_selections] == [
+        _OPEN_FILE_A_REQUEST_ID,
+        _OPEN_FILE_B_REQUEST_ID,
+    ]
+
+
 def test_selected_files_event_updates_file_picker_status() -> None:
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()

From 098e19fa779637f76709ee53899c97b31ba690aa Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 11:21:12 -0700
Subject: [PATCH 11/43] Complete leftover file picks as unavailable when the
 client is gone.

A dropped WebRTC peer or closed native window finishes queued ids so the app is not left waiting. A late picker cannot complete a later request that reused the same id.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  6 +-
 .../flashdreams/api_v2/client_window.py       |  8 +-
 flashdreams/flashdreams/api_v2/loop.py        |  4 +
 .../runtime_v2/file_selection_gate.py         | 50 +++++++++--
 .../runtime_v2/native_window_client_window.py | 19 ++++-
 .../runtime_v2/serving/webrtc_server.py       | 33 ++++---
 .../runtime_v2/user_input_event.py            |  2 +-
 .../runtime_v2/webrtc_client_window.py        | 18 ++++
 .../test_native_window_client_window.py       | 85 +++++++++++++++++++
 flashdreams/test_v2/test_selected_files.py    | 24 ++++++
 .../test_v2/test_webrtc_client_window.py      | 42 +++++++++
 11 files changed, 264 insertions(+), 27 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 86243cb35..f9016b5f5 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -236,7 +236,11 @@ outcome (`ok`, `cancelled`, `too_large`, `disallowed_type`, `unavailable`);
 `request_id` and reuse it after the matching event: extra clicks on that
 control while a picker is opening are ignored. A new id on every click is
 a new control and queues another dialog. Distinct controls use distinct
-ids and are served one client dialog at a time.
+ids and are served one client dialog at a time. Every accepted request later
+produces one event. `cancelled` is only a user dismiss. If the interactive
+client is gone while the session continues (dropped WebRTC peer, closed native
+window), leftovers complete as `unavailable`. A picker that outlives that
+client cannot complete a later request that reused the id.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index cd8a2653b..0cb71e2dd 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -71,7 +71,13 @@ def request_selected_files(
         extra clicks while the picker is opening do not enqueue more dialogs.
         A new id on every click is a new control and queues another dialog.
         A different ``request_id`` waits until the active selector completes,
-        so two controls still run one dialog at a time.
+        so two controls still run one dialog at a time. Every accepted request
+        later produces one event. ``cancelled`` is only a user dismiss. If the
+        interactive client is gone while the session continues (dropped WebRTC
+        peer, closed native window), leftovers complete as ``unavailable``. A
+        picker that outlives that client cannot complete a later request that
+        reused the id. Window ``close`` / session replacement finish leftovers
+        without delivering them to the next session.
 
         Args:
             request_id: Stable id for this selector slot, typically one per
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 37df84873..fb44e0ce0 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -564,6 +564,10 @@ def request_selected_files(
         ``request_id`` per UI control so extra clicks while the picker is
         opening are ignored; two controls use two ids and are served in order.
         A new id on every click is a new control and queues another dialog.
+        Every accepted request later produces one event. ``cancelled`` is only
+        a user dismiss. If the interactive client is gone while the session
+        continues (dropped WebRTC peer, closed native window), leftovers
+        complete as ``unavailable``.
 
         ``accept`` and ``max_bytes`` are the application's policy. Windows
         classify the choice with
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
index 5fea57b41..dffa22504 100644
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -8,7 +8,7 @@
 import logging
 import threading
 from collections import deque
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,12 +29,17 @@ class QueuedFileSelection:
     max_bytes: int | None
     """Requested size budget in bytes, or ``None`` for the window ceiling."""
 
+    generation: int = 0
+    """Client generation that admitted this request. Stale pickers do not match."""
+
 
 class FileSelectionGate:
     """Admit one client file selector at a time.
 
     A duplicate ``request_id`` that is already active or queued is ignored.
     A different id waits until :meth:`complete` for the active request.
+    :meth:`drain` finishes the current client generation so a late picker
+    cannot complete a later request that reused the id.
     """
 
     def __init__(self) -> None:
@@ -42,6 +47,7 @@ def __init__(self) -> None:
         self._lock = threading.Lock()
         self._active: QueuedFileSelection | None = None
         self._queued: deque[QueuedFileSelection] = deque()
+        self._generation = 0
 
     def submit(self, pending: QueuedFileSelection) -> QueuedFileSelection | None:
         """Record ``pending`` and return it when it should start now.
@@ -60,25 +66,32 @@ def submit(self, pending: QueuedFileSelection) -> QueuedFileSelection | None:
                     pending.request_id,
                 )
                 return None
+            stamped = replace(pending, generation=self._generation)
             if self._active is None:
-                self._active = pending
-                return pending
-            self._queued.append(pending)
+                self._active = stamped
+                return stamped
+            self._queued.append(stamped)
             return None
 
-    def complete(self, request_id: str) -> QueuedFileSelection | None:
+    def complete(
+        self, request_id: str, generation: int | None = None
+    ) -> QueuedFileSelection | None:
         """Release ``request_id`` and return the next request to start.
 
         Args:
             request_id: Id of the selector that just emitted an event.
+            generation: Client generation of that selector, or ``None`` to
+                match only the id.
 
         Returns:
-            The next queued request, or ``None`` when this id was not active or
-            the queue is empty.
+            The next queued request, or ``None`` when this id was not active,
+            the generation does not match, or the queue is empty.
         """
         with self._lock:
             if self._active is None or self._active.request_id != request_id:
                 return None
+            if generation is not None and self._active.generation != generation:
+                return None
             self._active = None
             if not self._queued:
                 return None
@@ -86,11 +99,30 @@ def complete(self, request_id: str) -> QueuedFileSelection | None:
             self._active = nxt
             return nxt
 
-    def clear(self) -> None:
-        """Drop the active request and every queued request."""
+    def is_current(self, request_id: str, generation: int) -> bool:
+        """Return whether ``request_id`` is still the active selector for ``generation``."""
         with self._lock:
+            return (
+                self._active is not None
+                and self._active.request_id == request_id
+                and self._active.generation == generation
+            )
+
+    def drain(self) -> tuple[QueuedFileSelection, ...]:
+        """Return and drop remaining requests, then start a new client generation."""
+        with self._lock:
+            items: list[QueuedFileSelection] = []
+            if self._active is not None:
+                items.append(self._active)
+            items.extend(self._queued)
             self._active = None
             self._queued.clear()
+            self._generation += 1
+            return tuple(items)
+
+    def clear(self) -> None:
+        """Drop remaining requests and start a new client generation."""
+        self.drain()
 
     def _contains(self, request_id: str) -> bool:
         if self._active is not None and self._active.request_id == request_id:
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index f7b159ef4..26138d9cf 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -327,6 +327,7 @@ def _spawn_file_picker(self, pending: QueuedFileSelection) -> None:
             target=self._complete_file_selection,
             args=(
                 pending.request_id,
+                pending.generation,
                 pending.initial_path or str(Path.home()),
                 pending.accept,
                 pending.max_bytes
@@ -341,6 +342,7 @@ def _spawn_file_picker(self, pending: QueuedFileSelection) -> None:
     def _complete_file_selection(
         self,
         request_id: str,
+        generation: int,
         initial_dir: str,
         accept: tuple[str, ...],
         max_bytes: int,
@@ -366,6 +368,8 @@ def _complete_file_selection(
                     files = () if chosen is None else (chosen,)
                 else:
                     status = SelectedFilesStatus.CANCELLED
+            if not self._file_gate.is_current(request_id, generation):
+                return
             started_ns = self._session_started_ns
             elapsed_ns = (
                 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
@@ -379,7 +383,7 @@ def _complete_file_selection(
                 )
             )
         finally:
-            nxt = self._file_gate.complete(request_id)
+            nxt = self._file_gate.complete(request_id, generation)
             if nxt is not None and self._presenter is not None:
                 self._spawn_file_picker(nxt)
 
@@ -597,8 +601,21 @@ def _on_window_closed(self) -> None:
         if self._close_event_enqueued:
             return
         self._close_event_enqueued = True
+        self._abandon_file_selections()
         self._put_input(CloseUserInputEvent(timestamp=uint64(0)))
 
+    def _abandon_file_selections(self) -> None:
+        """Complete leftover picks as unavailable; a late OS dialog cannot finish them."""
+        leftover = self._file_gate.drain()
+        for item in leftover:
+            self._put_input(
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=item.request_id,
+                    status=SelectedFilesStatus.UNAVAILABLE,
+                )
+            )
+
 
 class _SlangPyNativeWindowPresenter:
     """Own the SlangPy window and forward frames to its presentation context."""
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index b5675ea57..c15eaf47c 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -347,6 +347,7 @@ def __init__(
         self._port = port
         self._startup_timeout_seconds = startup_timeout_seconds
         self._input_callback: Callable[[UserInputEvent], None] | None = None
+        self._client_gone_callback: Callable[[], None] | None = None
         self._started = threading.Event()
         self._startup_error: BaseException | None = None
         self._loop: asyncio.AbstractEventLoop | None = None
@@ -529,20 +530,11 @@ def _invalidate_file_selectors(self) -> None:
             self._queued_file_selectors.clear()
 
     def _complete_abandoned_file_selectors(self) -> None:
-        """Complete pending selector requests as unavailable."""
-        timestamp_us = self._timestamp_us()
-        with self._file_selector_lock:
-            pending = tuple(self._pending_file_requests)
-            self._pending_file_requests.clear()
-            self._queued_file_selectors.clear()
-        if timestamp_us is None:
-            return
-        for request_id in pending:
-            self._emit_selected_files(
-                timestamp_us,
-                request_id,
-                status=SelectedFilesStatus.UNAVAILABLE,
-            )
+        """Finish leftover picks because the interactive client is gone."""
+        self._invalidate_file_selectors()
+        callback = self._client_gone_callback
+        if callback is not None:
+            callback()
 
     def _send_file_selector(self, payload: dict[str, Any]) -> None:
         """Send one file-selector request on the WebRTC event-loop thread."""
@@ -679,6 +671,19 @@ def register_input_callback(
             raise RuntimeError("An input callback is already registered.")
         self._input_callback = callback
 
+    def register_client_gone_callback(self, callback: Callable[[], None]) -> None:
+        """Register the function called when the browser peer is gone.
+
+        Args:
+            callback: Function with no arguments.
+
+        Raises:
+            RuntimeError: A callback has already been registered.
+        """
+        if self._client_gone_callback is not None:
+            raise RuntimeError("A client-gone callback is already registered.")
+        self._client_gone_callback = callback
+
     def write(self, result: StepResult) -> None:
         """Materialize and admit one generated result to the sender mailbox.
 
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 68c3d196d..64af3a9aa 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -315,7 +315,7 @@ class SelectedFilesStatus(Enum):
     """The chosen file did not match ``accept``. Checked before size."""
 
     UNAVAILABLE = "unavailable"
-    """No picker could run: headless output, a dropped peer, or an unreadable file."""
+    """No picker could run: headless output, a gone client, or an unreadable file."""
 
 
 def selected_file_policy_status(
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 4e48080cf..c6b80c8a6 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -19,6 +19,7 @@
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     UserInputEvent,
     normalize_selected_file_accept,
@@ -86,6 +87,7 @@ def handle_input(event: UserInputEvent) -> None:
                 self._start_file_selection(nxt)
 
         self.server.register_input_callback(handle_input)
+        self.server.register_client_gone_callback(self._abandon_file_selections)
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the browser window."""
@@ -146,6 +148,22 @@ def request_selected_files(
         if started is not None:
             self._start_file_selection(started)
 
+    def _abandon_file_selections(self) -> None:
+        """Complete leftover picks as unavailable; do not arm them for a later viewer."""
+        leftover = self._file_gate.drain()
+        if not leftover:
+            return
+        timestamp = self.server.event_timestamp_us()
+        with self._input_lock:
+            for item in leftover:
+                self._input_events.append(
+                    SelectedFilesUserInputEvent(
+                        timestamp=timestamp,
+                        request_id=item.request_id,
+                        status=SelectedFilesStatus.UNAVAILABLE,
+                    )
+                )
+
     def _start_file_selection(self, pending: QueuedFileSelection) -> None:
         """Arm the WebRTC server for one file-selector request."""
         self.server.request_selected_files(
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index de9f854e0..dd797a69d 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -756,6 +756,91 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     assert event.status is SelectedFilesStatus.CANCELLED
 
 
+def test_native_window_close_completes_leftover_file_selections(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    entered = threading.Event()
+    released = threading.Event()
+
+    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+        del initial_dir, accept
+        entered.set()
+        assert released.wait(timeout=2.0)
+        return ""
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files("open-2", str(tmp_path))
+    assert entered.wait(timeout=2.0)
+    presenter.pending_events.put(("close", None))
+    events = window.get_user_input_events().get_events()
+    released.set()
+    window.close()
+
+    assert [event.request_id for event in events[:-1]] == ["open-1", "open-2"]
+    assert all(
+        isinstance(event, SelectedFilesUserInputEvent)
+        and event.status is SelectedFilesStatus.UNAVAILABLE
+        and event.files == ()
+        for event in events[:-1]
+    )
+    assert isinstance(events[-1], CloseUserInputEvent)
+
+
+def test_native_window_stale_picker_does_not_complete_reused_request_id(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    first_entered = threading.Event()
+    first_released = threading.Event()
+    second_entered = threading.Event()
+    second_released = threading.Event()
+    zombie = tmp_path / "zombie.bin"
+    zombie.write_bytes(b"old")
+    calls: list[int] = []
+
+    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+        del initial_dir, accept
+        calls.append(1)
+        if len(calls) == 1:
+            first_entered.set()
+            assert first_released.wait(timeout=2.0)
+            return str(zombie)
+        second_entered.set()
+        assert second_released.wait(timeout=2.0)
+        return ""
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    assert first_entered.wait(timeout=2.0)
+    window.close()
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    assert second_entered.wait(timeout=2.0)
+    first_released.set()
+    time.sleep(0.05)
+    assert window.get_user_input_events().get_events() == []
+    second_released.set()
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.CANCELLED
+    assert event.files == ()
+
+
 def test_selected_file_from_path_skips_unreadable_and_oversize(
     tmp_path: Path,
 ) -> None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index c07227f4c..2a5184138 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -139,6 +139,30 @@ def test_file_selection_gate_clear_drops_queued_requests() -> None:
     assert started.request_id == "open-2"
 
 
+def test_file_selection_gate_drain_returns_active_then_queued() -> None:
+    gate = FileSelectionGate()
+    assert gate.submit(_queued("open-1")) is not None
+    assert gate.submit(_queued("open-2")) is None
+    nxt = gate.complete("open-1")
+    assert nxt is not None
+    assert [item.request_id for item in gate.drain()] == ["open-2"]
+    assert gate.drain() == ()
+
+
+def test_file_selection_gate_stale_complete_does_not_release_new_request() -> None:
+    gate = FileSelectionGate()
+    first = gate.submit(_queued("open-1"))
+    assert first is not None
+    stale_generation = first.generation
+    gate.drain()
+    second = gate.submit(_queued("open-1"))
+    assert second is not None
+    assert second.generation != stale_generation
+    assert gate.complete("open-1", generation=stale_generation) is None
+    assert gate.is_current("open-1", second.generation)
+    assert gate.complete("open-1", generation=second.generation) is None
+
+
 def test_selected_file_policy_helpers() -> None:
     assert clamp_selected_file_max_bytes(None) == MAX_SELECTED_FILE_BYTES
     assert clamp_selected_file_max_bytes(16) == 16
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 7ef2a415d..5252d777a 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -236,6 +236,48 @@ async def test_browser_file_selections_are_served_one_at_a_time() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_peer_loss_completes_queued_file_selections_as_unavailable() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    replacement: RTCPeerConnection | None = None
+    try:
+        peer, _, _ = await _connect_browser(window)
+        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files("open-2", "/tmp")
+        await _wait_file_armed(window, "open-1")
+        assert "open-2" not in window.server._pending_file_requests
+        await peer.close()
+        peer = None
+
+        events = []
+        for _ in range(100):
+            events.extend(window.get_user_input_events().get_events())
+            if len(events) >= 2:
+                break
+            await asyncio.sleep(0.01)
+        assert [event.request_id for event in events] == ["open-1", "open-2"]
+        assert all(
+            isinstance(event, SelectedFilesUserInputEvent)
+            and event.status is SelectedFilesStatus.UNAVAILABLE
+            and event.files == ()
+            for event in events
+        )
+        assert window.server._pending_file_requests == {}
+        assert window.server._queued_file_selectors == []
+
+        replacement, _, _ = await _connect_browser(window)
+        assert "open-2" not in window.server._pending_file_requests
+        assert window.server._queued_file_selectors == []
+    finally:
+        if peer is not None:
+            await peer.close()
+        if replacement is not None:
+            await replacement.close()
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_unsolicited_file_upload_is_rejected() -> None:
     window = WebRTCClientWindow()

From 54699065cf3595800ccc5d1b385b81d8689d5dea Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 12:28:01 -0700
Subject: [PATCH 12/43] Drop in-flight file picks when the client is gone.

Claim the shared gate slot before emitting so a late upload, delayed arm, or native worker cannot complete after drain.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |   5 +-
 .../flashdreams/api_v2/client_window.py       |   9 +-
 flashdreams/flashdreams/api_v2/loop.py        |  22 +--
 flashdreams/flashdreams/runtime_v2/README.md  |   3 +-
 .../runtime_v2/file_selection_gate.py         |  27 ++--
 .../runtime_v2/mp4_client_window.py           |   2 +-
 .../runtime_v2/native_window_client_window.py |  44 +++---
 .../runtime_v2/null_client_window.py          |   2 +-
 .../runtime_v2/serving/webrtc_server.py       | 140 ++++++++++++------
 .../runtime_v2/user_input_event.py            |   5 +-
 .../runtime_v2/webrtc_client_window.py        |  28 ++--
 .../test_native_window_client_window.py       |   7 +-
 flashdreams/test_v2/test_selected_files.py    |  25 +++-
 .../test_v2/test_webrtc_client_window.py      |  99 +++++++++++++
 integrations_v2/imgui_ui_demo/README.md       |   3 +-
 15 files changed, 309 insertions(+), 112 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index f9016b5f5..e7f96edc6 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -239,8 +239,9 @@ a new control and queues another dialog. Distinct controls use distinct
 ids and are served one client dialog at a time. Every accepted request later
 produces one event. `cancelled` is only a user dismiss. If the interactive
 client is gone while the session continues (dropped WebRTC peer, closed native
-window), leftovers complete as `unavailable`. A picker that outlives that
-client cannot complete a later request that reused the id.
+window), leftovers complete as `unavailable`. In-flight picks are dropped the
+same way. A picker that outlives that client cannot complete a later request that
+reused the id.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 0cb71e2dd..c555e546d 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -74,10 +74,11 @@ def request_selected_files(
         so two controls still run one dialog at a time. Every accepted request
         later produces one event. ``cancelled`` is only a user dismiss. If the
         interactive client is gone while the session continues (dropped WebRTC
-        peer, closed native window), leftovers complete as ``unavailable``. A
-        picker that outlives that client cannot complete a later request that
-        reused the id. Window ``close`` / session replacement finish leftovers
-        without delivering them to the next session.
+        peer, closed native window), leftovers complete as ``unavailable``.
+        In-flight picks are dropped the same way. A picker that outlives that
+        client cannot complete a later request that reused the id. Window
+        ``close`` / session replacement finish leftovers without delivering
+        them to the next session.
 
         Args:
             request_id: Stable id for this selector slot, typically one per
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index fb44e0ce0..170b7afa8 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -558,16 +558,18 @@ def request_selected_files(
         :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
         Read ``status`` for cancel, oversize, disallowed type, or unavailable;
         ``files`` is non-empty only when the pick succeeded. A second call with
-        the same ``request_id`` while the first is still queued is ignored so
-        the original picker can still complete. Distinct ids are forwarded in
-        order; the window shows one client selector at a time. Use one stable
-        ``request_id`` per UI control so extra clicks while the picker is
-        opening are ignored; two controls use two ids and are served in order.
-        A new id on every click is a new control and queues another dialog.
-        Every accepted request later produces one event. ``cancelled`` is only
-        a user dismiss. If the interactive client is gone while the session
-        continues (dropped WebRTC peer, closed native window), leftovers
-        complete as ``unavailable``.
+        the same ``request_id`` while the first is still active or queued is
+        ignored so the original picker can still complete. Distinct ids are
+        forwarded in order; the window shows one client selector at a time.
+        Use one stable ``request_id`` per UI control so extra clicks while the
+        picker is opening are ignored; two controls use two ids and are served
+        in order. A new id on every click is a new control and queues another
+        dialog. Every accepted request later produces one event. ``cancelled``
+        is only a user dismiss. If the interactive client is gone while the
+        session continues (dropped WebRTC peer, closed native window), leftovers
+        complete as ``unavailable``. In-flight picks are dropped the same way.
+        A picker that outlives that client cannot complete a later request that
+        reused the id.
 
         ``accept`` and ``max_bytes`` are the application's policy. Windows
         classify the choice with
diff --git a/flashdreams/flashdreams/runtime_v2/README.md b/flashdreams/flashdreams/runtime_v2/README.md
index 285751682..db5a62a47 100644
--- a/flashdreams/flashdreams/runtime_v2/README.md
+++ b/flashdreams/flashdreams/runtime_v2/README.md
@@ -346,7 +346,8 @@ fully resolved replacement description. `run_session` stops and cleans the
 current session, leaves the interactive window open, and returns that
 description unchanged. `ApplicationRunner` creates the replacement from it. A
 WebRTC browser disconnect releases only its peer connection, so refreshing the
-page does not stop the session, server, or application.
+page does not stop the session, server, or application. Leftover and in-flight
+file picks complete as `unavailable`; a replacement viewer does not inherit them.
 
 The UI thread owns WebRTC cadence. Each `write` synchronously materializes one
 owned video frame and admits it to a two-frame FIFO of unsent frames. The WebRTC
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
index dffa22504..0e317a67c 100644
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -38,8 +38,9 @@ class FileSelectionGate:
 
     A duplicate ``request_id`` that is already active or queued is ignored.
     A different id waits until :meth:`complete` for the active request.
-    :meth:`drain` finishes the current client generation so a late picker
-    cannot complete a later request that reused the id.
+    Callers emit a selected-files event only after :meth:`complete` claims
+    the slot. :meth:`drain` finishes the current client generation so a late
+    picker or upload cannot complete a later request that reused the id.
     """
 
     def __init__(self) -> None:
@@ -75,29 +76,33 @@ def submit(self, pending: QueuedFileSelection) -> QueuedFileSelection | None:
 
     def complete(
         self, request_id: str, generation: int | None = None
-    ) -> QueuedFileSelection | None:
-        """Release ``request_id`` and return the next request to start.
+    ) -> tuple[bool, QueuedFileSelection | None]:
+        """Claim ``request_id`` if it is still current and return the next start.
+
+        Callers emit a result only when this returns ``claimed=True``. Client-gone
+        :meth:`drain` wins the race against in-flight pickers and uploads.
 
         Args:
-            request_id: Id of the selector that just emitted an event.
+            request_id: Id of the in-flight selector.
             generation: Client generation of that selector, or ``None`` to
                 match only the id.
 
         Returns:
-            The next queued request, or ``None`` when this id was not active,
-            the generation does not match, or the queue is empty.
+            ``(True, next)`` when this in-flight work still owned the slot.
+            ``next`` is the request that should start now, or ``None`` if the
+            queue is empty. ``(False, None)`` when the id is not current.
         """
         with self._lock:
             if self._active is None or self._active.request_id != request_id:
-                return None
+                return False, None
             if generation is not None and self._active.generation != generation:
-                return None
+                return False, None
             self._active = None
             if not self._queued:
-                return None
+                return True, None
             nxt = self._queued.popleft()
             self._active = nxt
-            return nxt
+            return True, nxt
 
     def is_current(self, request_id: str, generation: int) -> bool:
         """Return whether ``request_id`` is still the active selector for ``generation``."""
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index c02599995..0705927d1 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -90,7 +90,7 @@ def request_selected_files(
                     status=SelectedFilesStatus.UNAVAILABLE,
                 )
             )
-            started = self._file_gate.complete(started.request_id)
+            _, started = self._file_gate.complete(started.request_id)
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the MP4 presentation dimensions without replacing the session.
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 26138d9cf..85912fb50 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -301,7 +301,8 @@ def request_selected_files(
 
         The desktop dialog runs on a worker thread so the UI loop can keep
         polling and presenting while the picker is open. A second distinct
-        ``request_id`` waits until this picker completes.
+        ``request_id`` waits until this picker completes. Closing the window
+        completes leftovers and in-flight picks as unavailable.
 
         Args:
             request_id: Stable selector-slot id from the UI control.
@@ -368,22 +369,22 @@ def _complete_file_selection(
                     files = () if chosen is None else (chosen,)
                 else:
                     status = SelectedFilesStatus.CANCELLED
-            if not self._file_gate.is_current(request_id, generation):
-                return
-            started_ns = self._session_started_ns
-            elapsed_ns = (
-                0 if started_ns is None else max(0, self._clock_ns() - started_ns)
-            )
-            self._input_events.put(
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(elapsed_ns // 1_000),
-                    request_id=request_id,
-                    status=status,
-                    files=files,
-                )
-            )
         finally:
-            nxt = self._file_gate.complete(request_id, generation)
+            claimed, nxt = self._file_gate.complete(request_id, generation)
+            if claimed:
+                started_ns = self._session_started_ns
+                elapsed_ns = (
+                    0 if started_ns is None else max(0, self._clock_ns() - started_ns)
+                )
+                self._input_events.put(
+                    SelectedFilesUserInputEvent(
+                        timestamp=uint64(elapsed_ns // 1_000),
+                        request_id=request_id,
+                        status=status,
+                        files=files,
+                        generation=generation,
+                    )
+                )
             if nxt is not None and self._presenter is not None:
                 self._spawn_file_picker(nxt)
 
@@ -506,7 +507,7 @@ def write(self, result: StepResult) -> None:
 
     def close(self) -> None:
         """Release SlangPy and the GLFW window on the runtime's UI thread."""
-        self._file_gate.clear()
+        self._invalidate_file_selections(deliver_unavailable=False)
         presenter = self._presenter
         self._presenter = None
         self._session_started_ns = None
@@ -601,18 +602,21 @@ def _on_window_closed(self) -> None:
         if self._close_event_enqueued:
             return
         self._close_event_enqueued = True
-        self._abandon_file_selections()
+        self._invalidate_file_selections(deliver_unavailable=True)
         self._put_input(CloseUserInputEvent(timestamp=uint64(0)))
 
-    def _abandon_file_selections(self) -> None:
-        """Complete leftover picks as unavailable; a late OS dialog cannot finish them."""
+    def _invalidate_file_selections(self, *, deliver_unavailable: bool) -> None:
+        """Finish this client generation; optionally report leftovers as unavailable."""
         leftover = self._file_gate.drain()
+        if not deliver_unavailable:
+            return
         for item in leftover:
             self._put_input(
                 SelectedFilesUserInputEvent(
                     timestamp=uint64(0),
                     request_id=item.request_id,
                     status=SelectedFilesStatus.UNAVAILABLE,
+                    generation=item.generation,
                 )
             )
 
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index 8fdd80680..32d215a68 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -72,7 +72,7 @@ def request_selected_files(
                     status=SelectedFilesStatus.UNAVAILABLE,
                 )
             )
-            started = self._file_gate.complete(started.request_id)
+            _, started = self._file_gate.complete(started.request_id)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Accept a session without opening an output."""
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index c15eaf47c..b2a86f811 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -312,8 +312,8 @@ class _PendingFileSelection:
     max_bytes: int
     """Maximum file bytes, already clamped to the window ceiling."""
 
-    epoch: int
-    """Session epoch that armed this request; later epochs drop the result."""
+    generation: int
+    """Gate generation that armed this request; a later generation drops it."""
 
 
 class WebRTCServer:
@@ -347,7 +347,10 @@ def __init__(
         self._port = port
         self._startup_timeout_seconds = startup_timeout_seconds
         self._input_callback: Callable[[UserInputEvent], None] | None = None
-        self._client_gone_callback: Callable[[], None] | None = None
+        self._file_selection_current_callback: (
+            Callable[[str, int], bool] | None
+        ) = None
+        self._file_selection_invalidate_callback: Callable[[bool], None] | None = None
         self._started = threading.Event()
         self._startup_error: BaseException | None = None
         self._loop: asyncio.AbstractEventLoop | None = None
@@ -369,10 +372,9 @@ def __init__(
         self._client_connected = False
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._queued_file_selectors: list[dict[str, Any]] = []
+        self._queued_file_selectors: list[tuple[dict[str, Any], int]] = []
         self._pending_file_requests: dict[str, _PendingFileSelection] = {}
         self._file_selector_lock = threading.Lock()
-        self._file_selection_epoch = 0
         self._thread = threading.Thread(
             target=self._run_server,
             name="flashdreams-webrtc",
@@ -470,6 +472,7 @@ def request_selected_files(
         *,
         accept: Sequence[str] = (),
         max_bytes: int | None = None,
+        generation: int,
     ) -> None:
         """Ask the connected browser to open a file selector.
 
@@ -478,6 +481,7 @@ def request_selected_files(
             initial_path: Ignored; the browser picker cannot use a host path.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
+            generation: Gate generation that admitted this request.
         """
         del initial_path
         if not isinstance(request_id, str) or not request_id:
@@ -493,9 +497,9 @@ def request_selected_files(
         loop = self._loop
         if loop is None:
             raise RuntimeError("WebRTC server is not running.")
-        loop.call_soon_threadsafe(self._arm_file_selector, payload)
+        loop.call_soon_threadsafe(self._arm_file_selector, payload, generation)
 
-    def _arm_file_selector(self, payload: dict[str, Any]) -> None:
+    def _arm_file_selector(self, payload: dict[str, Any], generation: int) -> None:
         """Record pending policy and send or queue the selector request."""
         request_id = payload["id"]
         if not isinstance(request_id, str):
@@ -505,12 +509,18 @@ def _arm_file_selector(self, payload: dict[str, Any]) -> None:
         if not isinstance(accept, list) or not isinstance(max_bytes, int):
             raise TypeError("file selector payload must include accept and max_bytes.")
         with self._file_selector_lock:
+            if not self._file_selection_is_current(request_id, generation):
+                return
             self._pending_file_requests[request_id] = _PendingFileSelection(
                 accept=tuple(accept),
                 max_bytes=max_bytes,
-                epoch=self._file_selection_epoch,
+                generation=generation,
             )
-        self._send_file_selector(payload)
+            channel = self._control_channel
+            if channel is None or channel.readyState != "open":
+                self._queued_file_selectors.append((payload, generation))
+                return
+        channel.send(json.dumps(payload))
 
     def _take_pending_file_request(
         self, request_id: str
@@ -519,37 +529,51 @@ def _take_pending_file_request(
         with self._file_selector_lock:
             return self._pending_file_requests.pop(request_id, None)
 
-    def _file_selection_belongs_to_current_session(self, epoch: int) -> bool:
-        """Return whether ``epoch`` was armed for the open session."""
-        return not self._closed and epoch == self._file_selection_epoch
+    def _file_selection_is_current(self, request_id: str, generation: int) -> bool:
+        """Return whether the window gate still owns this in-flight request."""
+        if self._closed:
+            return False
+        callback = self._file_selection_current_callback
+        if callback is None:
+            return False
+        return callback(request_id, generation)
 
-    def _invalidate_file_selectors(self) -> None:
-        """Drop queued and pending selector requests without completing them."""
+    def _invalidate_file_selectors(self, *, deliver_unavailable: bool) -> None:
+        """Drop transport state and finish the window's current file generation."""
         with self._file_selector_lock:
             self._pending_file_requests.clear()
             self._queued_file_selectors.clear()
+            callback = self._file_selection_invalidate_callback
+            if callback is not None:
+                callback(deliver_unavailable)
 
     def _complete_abandoned_file_selectors(self) -> None:
         """Finish leftover picks because the interactive client is gone."""
-        self._invalidate_file_selectors()
-        callback = self._client_gone_callback
-        if callback is not None:
-            callback()
-
-    def _send_file_selector(self, payload: dict[str, Any]) -> None:
-        """Send one file-selector request on the WebRTC event-loop thread."""
-        channel = self._control_channel
-        if channel is None or channel.readyState != "open":
-            self._queued_file_selectors.append(payload)
-            return
-        channel.send(json.dumps(payload))
+        self._invalidate_file_selectors(deliver_unavailable=True)
 
     def _flush_queued_file_selectors(self) -> None:
         """Send file-selector requests that arrived before the datachannel opened."""
-        queued = self._queued_file_selectors
-        self._queued_file_selectors = []
-        for payload in queued:
-            self._send_file_selector(payload)
+        with self._file_selector_lock:
+            queued = self._queued_file_selectors
+            self._queued_file_selectors = []
+            ready: list[tuple[dict[str, Any], int]] = []
+            for payload, generation in queued:
+                request_id = payload["id"]
+                if isinstance(request_id, str) and self._file_selection_is_current(
+                    request_id, generation
+                ):
+                    ready.append((payload, generation))
+        for payload, generation in ready:
+            channel = self._control_channel
+            if channel is None or channel.readyState != "open":
+                with self._file_selector_lock:
+                    request_id = payload["id"]
+                    if isinstance(
+                        request_id, str
+                    ) and self._file_selection_is_current(request_id, generation):
+                        self._queued_file_selectors.append((payload, generation))
+                continue
+            channel.send(json.dumps(payload))
 
     def event_timestamp_us(self) -> np.uint64:
         """Return the current timestamp relative to this server's first session.
@@ -613,8 +637,7 @@ def open(self, session_desc: SessionDesc) -> None:
             # Keep timestamps comparable across sessions so events buffered
             # during a handoff retain their real order.
             self._event_origin_ns = time.monotonic_ns()
-        self._file_selection_epoch += 1
-        self._invalidate_file_selectors()
+        self._invalidate_file_selectors(deliver_unavailable=False)
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the dimensions used to present subsequent UI frames.
@@ -671,18 +694,41 @@ def register_input_callback(
             raise RuntimeError("An input callback is already registered.")
         self._input_callback = callback
 
-    def register_client_gone_callback(self, callback: Callable[[], None]) -> None:
-        """Register the function called when the browser peer is gone.
+    def register_file_selection_current_callback(
+        self, callback: Callable[[str, int], bool]
+    ) -> None:
+        """Register the gate check for in-flight file-selector work.
 
         Args:
-            callback: Function with no arguments.
+            callback: ``True`` when ``request_id`` is still current for
+                ``generation``.
 
         Raises:
             RuntimeError: A callback has already been registered.
         """
-        if self._client_gone_callback is not None:
-            raise RuntimeError("A client-gone callback is already registered.")
-        self._client_gone_callback = callback
+        if self._file_selection_current_callback is not None:
+            raise RuntimeError(
+                "A file-selection current callback is already registered."
+            )
+        self._file_selection_current_callback = callback
+
+    def register_file_selection_invalidate_callback(
+        self, callback: Callable[[bool], None]
+    ) -> None:
+        """Register the function that finishes a file-selection generation.
+
+        Args:
+            callback: Called with ``True`` to emit ``unavailable`` for leftovers
+                and ``False`` to drop them without delivering.
+
+        Raises:
+            RuntimeError: A callback has already been registered.
+        """
+        if self._file_selection_invalidate_callback is not None:
+            raise RuntimeError(
+                "A file-selection invalidate callback is already registered."
+            )
+        self._file_selection_invalidate_callback = callback
 
     def write(self, result: StepResult) -> None:
         """Materialize and admit one generated result to the sender mailbox.
@@ -913,7 +959,7 @@ def emit(
             status: SelectedFilesStatus,
             files: tuple[SelectedFile, ...] = (),
         ) -> None:
-            if not self._file_selection_belongs_to_current_session(policy.epoch):
+            if not self._file_selection_is_current(request_id, policy.generation):
                 raise web.HTTPConflict(
                     reason="No pending file selection for this request_id."
                 )
@@ -922,6 +968,7 @@ def emit(
                 request_id,
                 status=status,
                 files=files,
+                generation=policy.generation,
             )
 
         try:
@@ -1287,13 +1334,18 @@ def _buffer_browser_message(
                     "File selector result must not set status ok; send files "
                     "with POST /api/files."
                 )
-            if self._take_pending_file_request(request_id) is None:
+            policy = self._take_pending_file_request(request_id)
+            if policy is None:
                 return
-            event = SelectedFilesUserInputEvent(
-                timestamp=timestamp_us,
-                request_id=request_id,
+            if not self._file_selection_is_current(request_id, policy.generation):
+                return
+            self._emit_selected_files(
+                timestamp_us,
+                request_id,
                 status=status,
+                generation=policy.generation,
             )
+            return
         else:
             raise ValueError("Unsupported browser event type.")
         self._append_event(event)
@@ -1312,6 +1364,7 @@ def _emit_selected_files(
         *,
         status: SelectedFilesStatus,
         files: tuple[SelectedFile, ...] = (),
+        generation: int,
     ) -> None:
         """Append one selected-files event."""
         self._append_event(
@@ -1320,6 +1373,7 @@ def _emit_selected_files(
                 request_id=request_id,
                 status=status,
                 files=files,
+                generation=generation,
             )
         )
 
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 64af3a9aa..efb75b11d 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -315,7 +315,7 @@ class SelectedFilesStatus(Enum):
     """The chosen file did not match ``accept``. Checked before size."""
 
     UNAVAILABLE = "unavailable"
-    """No picker could run: headless output, a gone client, or an unreadable file."""
+    """The picker could not complete: headless output, a gone client, or an unreadable file."""
 
 
 def selected_file_policy_status(
@@ -381,6 +381,9 @@ def get_type_name(cls) -> str:
     files: tuple[SelectedFile, ...] = ()
     """Chosen files. Empty unless ``status`` is ``OK``."""
 
+    generation: int = 0
+    """Window generation that admitted this request. Applications ignore it."""
+
     def __post_init__(self) -> None:
         """Reject an ``ok`` event without files, or files on a failed pick."""
         has_files = bool(self.files)
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index c6b80c8a6..b5992f4c5 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -42,7 +42,8 @@ class WebRTCClientWindow(IClientWindow):
 
     Disconnecting releases only that browser's peer connection. The server and
     current session stay available for a refreshed or replacement client until
-    the application is explicitly stopped.
+    the application is explicitly stopped. Leftover and in-flight file picks
+    complete as unavailable; a replacement viewer does not inherit them.
     """
 
     def __init__(
@@ -81,13 +82,20 @@ def handle_input(event: UserInputEvent) -> None:
             nxt = None
             with self._input_lock:
                 if isinstance(event, SelectedFilesUserInputEvent):
-                    nxt = self._file_gate.complete(event.request_id)
+                    claimed, nxt = self._file_gate.complete(
+                        event.request_id, event.generation
+                    )
+                    if not claimed:
+                        return
                 self._input_events.append(event)
             if nxt is not None:
                 self._start_file_selection(nxt)
 
         self.server.register_input_callback(handle_input)
-        self.server.register_client_gone_callback(self._abandon_file_selections)
+        self.server.register_file_selection_current_callback(self._file_gate.is_current)
+        self.server.register_file_selection_invalidate_callback(
+            self._invalidate_file_selections
+        )
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the browser window."""
@@ -128,7 +136,8 @@ def request_selected_files(
         """Ask the connected browser to open a file selector.
 
         A second distinct ``request_id`` waits until the active selector
-        completes so the viewer shows one dialog at a time.
+        completes so the viewer shows one dialog at a time. A dropped peer
+        completes leftovers and in-flight picks as unavailable.
 
         Args:
             request_id: Stable selector-slot id from the UI control.
@@ -148,10 +157,10 @@ def request_selected_files(
         if started is not None:
             self._start_file_selection(started)
 
-    def _abandon_file_selections(self) -> None:
-        """Complete leftover picks as unavailable; do not arm them for a later viewer."""
+    def _invalidate_file_selections(self, deliver_unavailable: bool) -> None:
+        """Finish this client generation; optionally report leftovers as unavailable."""
         leftover = self._file_gate.drain()
-        if not leftover:
+        if not deliver_unavailable or not leftover:
             return
         timestamp = self.server.event_timestamp_us()
         with self._input_lock:
@@ -161,6 +170,7 @@ def _abandon_file_selections(self) -> None:
                         timestamp=timestamp,
                         request_id=item.request_id,
                         status=SelectedFilesStatus.UNAVAILABLE,
+                        generation=item.generation,
                     )
                 )
 
@@ -171,6 +181,7 @@ def _start_file_selection(self, pending: QueuedFileSelection) -> None:
             initial_path=pending.initial_path,
             accept=pending.accept,
             max_bytes=pending.max_bytes,
+            generation=pending.generation,
         )
 
     def open(self, session_desc: SessionDesc) -> None:
@@ -183,7 +194,6 @@ def open(self, session_desc: SessionDesc) -> None:
         session_event_offset_us = self.server.event_timestamp_us()
         with self._input_lock:
             self._input_events.clear()
-            self._file_gate.clear()
             self._session_event_offset_us = session_event_offset_us
 
     def get_user_input_events(self) -> UserInputEvents:
@@ -225,5 +235,5 @@ def metrics_snapshot(self) -> dict[str, float | int]:
 
     def close(self) -> None:
         """Implement ``OutputSink.close`` by releasing WebRTC resources."""
-        self._file_gate.clear()
+        self._invalidate_file_selections(False)
         self.server.close()
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index dd797a69d..7c98391c6 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -761,12 +761,14 @@ def test_native_window_close_completes_leftover_file_selections(
 ) -> None:
     entered = threading.Event()
     released = threading.Event()
+    late = tmp_path / "late.bin"
+    late.write_bytes(b"late")
 
     def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         del initial_dir, accept
         entered.set()
         assert released.wait(timeout=2.0)
-        return ""
+        return str(late)
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
@@ -780,8 +782,11 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     presenter.pending_events.put(("close", None))
     events = window.get_user_input_events().get_events()
     released.set()
+    time.sleep(0.05)
+    extra = window.get_user_input_events().get_events()
     window.close()
 
+    assert extra == []
     assert [event.request_id for event in events[:-1]] == ["open-1", "open-2"]
     assert all(
         isinstance(event, SelectedFilesUserInputEvent)
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 2a5184138..2366c9784 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -121,11 +121,12 @@ def test_file_selection_gate_ignores_duplicates_and_serves_one_at_a_time() -> No
     assert gate.submit(_queued("open-1")) is None
     assert gate.submit(_queued("open-2")) is None
     assert gate.submit(_queued("open-2")) is None
-    assert gate.complete("open-2") is None
-    nxt = gate.complete("open-1")
+    assert gate.complete("open-2") == (False, None)
+    claimed, nxt = gate.complete("open-1")
+    assert claimed
     assert nxt is not None
     assert nxt.request_id == "open-2"
-    assert gate.complete("open-2") is None
+    assert gate.complete("open-2") == (True, None)
 
 
 def test_file_selection_gate_clear_drops_queued_requests() -> None:
@@ -133,7 +134,7 @@ def test_file_selection_gate_clear_drops_queued_requests() -> None:
     assert gate.submit(_queued("open-1")) is not None
     assert gate.submit(_queued("open-2")) is None
     gate.clear()
-    assert gate.complete("open-1") is None
+    assert gate.complete("open-1") == (False, None)
     started = gate.submit(_queued("open-2"))
     assert started is not None
     assert started.request_id == "open-2"
@@ -143,7 +144,8 @@ def test_file_selection_gate_drain_returns_active_then_queued() -> None:
     gate = FileSelectionGate()
     assert gate.submit(_queued("open-1")) is not None
     assert gate.submit(_queued("open-2")) is None
-    nxt = gate.complete("open-1")
+    claimed, nxt = gate.complete("open-1")
+    assert claimed
     assert nxt is not None
     assert [item.request_id for item in gate.drain()] == ["open-2"]
     assert gate.drain() == ()
@@ -158,9 +160,18 @@ def test_file_selection_gate_stale_complete_does_not_release_new_request() -> No
     second = gate.submit(_queued("open-1"))
     assert second is not None
     assert second.generation != stale_generation
-    assert gate.complete("open-1", generation=stale_generation) is None
+    assert gate.complete("open-1", generation=stale_generation) == (False, None)
     assert gate.is_current("open-1", second.generation)
-    assert gate.complete("open-1", generation=second.generation) is None
+    assert gate.complete("open-1", generation=second.generation) == (True, None)
+
+
+def test_file_selection_gate_complete_after_drain_is_not_claimed() -> None:
+    gate = FileSelectionGate()
+    first = gate.submit(_queued("open-1"))
+    assert first is not None
+    leftover = gate.drain()
+    assert leftover[0].request_id == "open-1"
+    assert gate.complete("open-1", first.generation) == (False, None)
 
 
 def test_selected_file_policy_helpers() -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 5252d777a..728bd9059 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -278,6 +278,105 @@ async def test_peer_loss_completes_queued_file_selections_as_unavailable() -> No
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_in_flight_upload_is_dropped_after_peer_loss(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, _, _ = await _connect_browser(window)
+        window.request_selected_files("open-1", "/tmp")
+        await _wait_file_armed(window, "open-1")
+        original_post = web.Request.post
+        disconnected = False
+
+        async def post_after_disconnect(request: web.Request) -> Any:
+            nonlocal disconnected
+            if not disconnected:
+                disconnected = True
+                peer_connection = window.server._peer_connection
+                if peer_connection is not None:
+                    await window.server._release_peer_connection(peer_connection)
+            return await original_post(request)
+
+        monkeypatch.setattr(web.Request, "post", post_after_disconnect)
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
+        events = []
+        for _ in range(100):
+            events.extend(window.get_user_input_events().get_events())
+            if events:
+                break
+            await asyncio.sleep(0.01)
+        assert len(events) == 1
+        event = events[0]
+        assert isinstance(event, SelectedFilesUserInputEvent)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+        assert event.files == ()
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_stale_file_selector_arm_is_ignored_after_peer_loss() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    replacement: RTCPeerConnection | None = None
+    try:
+        peer, _, _ = await _connect_browser(window)
+        delayed: list[tuple[dict[str, object], int]] = []
+        original_arm = window.server._arm_file_selector
+
+        def capture_arm(payload: dict[str, object], generation: int) -> None:
+            delayed.append((payload, generation))
+
+        window.server._arm_file_selector = capture_arm  # type: ignore[method-assign]
+        window.request_selected_files("open-1", "/tmp")
+        for _ in range(100):
+            if delayed:
+                break
+            await asyncio.sleep(0.01)
+        assert delayed
+
+        await peer.close()
+        peer = None
+        events = []
+        for _ in range(100):
+            events.extend(window.get_user_input_events().get_events())
+            if events:
+                break
+            await asyncio.sleep(0.01)
+        assert len(events) == 1
+        event = events[0]
+        assert isinstance(event, SelectedFilesUserInputEvent)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+
+        payload, generation = delayed[0]
+        loop = window.server._loop
+        assert loop is not None
+        loop.call_soon_threadsafe(original_arm, payload, generation)
+        await asyncio.sleep(0.05)
+        assert window.server._pending_file_requests == {}
+        assert window.server._queued_file_selectors == []
+
+        replacement, _, _ = await _connect_browser(window)
+        await asyncio.sleep(0.05)
+        assert window.server._pending_file_requests == {}
+        assert window.server._queued_file_selectors == []
+    finally:
+        if peer is not None:
+            await peer.close()
+        if replacement is not None:
+            await replacement.close()
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_unsolicited_file_upload_is_rejected() -> None:
     window = WebRTCClientWindow()
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index cc6f4ee41..5de22a4e9 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -12,7 +12,8 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
   name and size (the file bytes are on the event; apps should use those).
   Each Open control uses a stable `request_id`. Extra clicks on the same
   control while a picker is open are ignored; **Open A then B** queues both
-  selectors one at a time.
+  selectors one at a time. Closing the native window or dropping the WebRTC
+  tab completes leftover picks as unavailable.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.

From 3823bf36df6bdbec5c4288342d74dcdb735cadf7 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 12:31:04 -0700
Subject: [PATCH 13/43] Narrow selected-file test assertions so ty can
 type-check them.

CI cpu pre-commit failed because UserInputEvent has no request_id or files until the list is filtered to SelectedFilesUserInputEvent.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 .../test_native_window_client_window.py       | 22 ++++++------
 flashdreams/test_v2/test_selected_files.py    | 22 ++++++------
 .../test_v2/test_webrtc_client_window.py      | 36 ++++++++++---------
 3 files changed, 42 insertions(+), 38 deletions(-)

diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 7c98391c6..5eaae0973 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -710,12 +710,11 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         time.sleep(0.01)
     window.close()
 
-    assert [event.request_id for event in events] == ["open-1", "open-2"]
-    assert all(
-        isinstance(event, SelectedFilesUserInputEvent)
-        and event.status is SelectedFilesStatus.CANCELLED
-        for event in events
-    )
+    picks = [
+        event for event in events if isinstance(event, SelectedFilesUserInputEvent)
+    ]
+    assert [event.request_id for event in picks] == ["open-1", "open-2"]
+    assert all(event.status is SelectedFilesStatus.CANCELLED for event in picks)
     assert calls == [(".bin",), (".raw",)]
 
 
@@ -787,12 +786,13 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     window.close()
 
     assert extra == []
-    assert [event.request_id for event in events[:-1]] == ["open-1", "open-2"]
+    picks = [
+        event for event in events[:-1] if isinstance(event, SelectedFilesUserInputEvent)
+    ]
+    assert [event.request_id for event in picks] == ["open-1", "open-2"]
     assert all(
-        isinstance(event, SelectedFilesUserInputEvent)
-        and event.status is SelectedFilesStatus.UNAVAILABLE
-        and event.files == ()
-        for event in events[:-1]
+        event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
+        for event in picks
     )
     assert isinstance(events[-1], CloseUserInputEvent)
 
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 2366c9784..38e322adc 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -244,12 +244,13 @@ def test_mp4_window_completes_queued_file_selections_as_unavailable(
 
     events = window.get_user_input_events().get_events()
 
-    assert [event.request_id for event in events] == ["open-1", "open-2"]
+    picks = [
+        event for event in events if isinstance(event, SelectedFilesUserInputEvent)
+    ]
+    assert [event.request_id for event in picks] == ["open-1", "open-2"]
     assert all(
-        isinstance(event, SelectedFilesUserInputEvent)
-        and event.status is SelectedFilesStatus.UNAVAILABLE
-        and event.files == ()
-        for event in events
+        event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
+        for event in picks
     )
 
 
@@ -260,10 +261,11 @@ def test_null_window_completes_file_selection_as_unavailable() -> None:
 
     events = window.get_user_input_events().get_events()
 
-    assert [event.request_id for event in events] == ["open-1", "open-2"]
+    picks = [
+        event for event in events if isinstance(event, SelectedFilesUserInputEvent)
+    ]
+    assert [event.request_id for event in picks] == ["open-1", "open-2"]
     assert all(
-        isinstance(event, SelectedFilesUserInputEvent)
-        and event.status is SelectedFilesStatus.UNAVAILABLE
-        and event.files == ()
-        for event in events
+        event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
+        for event in picks
     )
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 728bd9059..7816cd222 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -224,14 +224,13 @@ async def test_browser_file_selections_are_served_one_at_a_time() -> None:
             if len(events) >= 2:
                 break
             await asyncio.sleep(0.01)
-        assert [event.request_id for event in events] == ["open-1", "open-2"]
-        assert all(
-            isinstance(event, SelectedFilesUserInputEvent)
-            and event.status is SelectedFilesStatus.OK
-            for event in events
-        )
-        assert events[0].files[0].data == b"first"
-        assert events[1].files[0].data == b"second"
+        picks = [
+            event for event in events if isinstance(event, SelectedFilesUserInputEvent)
+        ]
+        assert [event.request_id for event in picks] == ["open-1", "open-2"]
+        assert all(event.status is SelectedFilesStatus.OK for event in picks)
+        assert picks[0].files[0].data == b"first"
+        assert picks[1].files[0].data == b"second"
     finally:
         window.close()
 
@@ -257,12 +256,13 @@ async def test_peer_loss_completes_queued_file_selections_as_unavailable() -> No
             if len(events) >= 2:
                 break
             await asyncio.sleep(0.01)
-        assert [event.request_id for event in events] == ["open-1", "open-2"]
+        picks = [
+            event for event in events if isinstance(event, SelectedFilesUserInputEvent)
+        ]
+        assert [event.request_id for event in picks] == ["open-1", "open-2"]
         assert all(
-            isinstance(event, SelectedFilesUserInputEvent)
-            and event.status is SelectedFilesStatus.UNAVAILABLE
-            and event.files == ()
-            for event in events
+            event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
+            for event in picks
         )
         assert window.server._pending_file_requests == {}
         assert window.server._queued_file_selectors == []
@@ -322,20 +322,22 @@ async def post_after_disconnect(request: web.Request) -> Any:
 
 
 @pytest.mark.asyncio
-async def test_stale_file_selector_arm_is_ignored_after_peer_loss() -> None:
+async def test_stale_file_selector_arm_is_ignored_after_peer_loss(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     peer: RTCPeerConnection | None = None
     replacement: RTCPeerConnection | None = None
     try:
         peer, _, _ = await _connect_browser(window)
-        delayed: list[tuple[dict[str, object], int]] = []
+        delayed: list[tuple[dict[str, Any], int]] = []
         original_arm = window.server._arm_file_selector
 
-        def capture_arm(payload: dict[str, object], generation: int) -> None:
+        def capture_arm(payload: dict[str, Any], generation: int) -> None:
             delayed.append((payload, generation))
 
-        window.server._arm_file_selector = capture_arm  # type: ignore[method-assign]
+        monkeypatch.setattr(window.server, "_arm_file_selector", capture_arm)
         window.request_selected_files("open-1", "/tmp")
         for _ in range(100):
             if delayed:

From c4d55bfc8cd231b073f626f3f0a5446abe32997d Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 12:42:27 -0700
Subject: [PATCH 14/43] Format webrtc_server.py to match the ruff-format hook.

CPU CI failed because pre-commit rewrote two type/if wraps in the file-selection path.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 .../flashdreams/runtime_v2/serving/webrtc_server.py    | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index b2a86f811..c5d371ad5 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -347,9 +347,7 @@ def __init__(
         self._port = port
         self._startup_timeout_seconds = startup_timeout_seconds
         self._input_callback: Callable[[UserInputEvent], None] | None = None
-        self._file_selection_current_callback: (
-            Callable[[str, int], bool] | None
-        ) = None
+        self._file_selection_current_callback: Callable[[str, int], bool] | None = None
         self._file_selection_invalidate_callback: Callable[[bool], None] | None = None
         self._started = threading.Event()
         self._startup_error: BaseException | None = None
@@ -568,9 +566,9 @@ def _flush_queued_file_selectors(self) -> None:
             if channel is None or channel.readyState != "open":
                 with self._file_selector_lock:
                     request_id = payload["id"]
-                    if isinstance(
-                        request_id, str
-                    ) and self._file_selection_is_current(request_id, generation):
+                    if isinstance(request_id, str) and self._file_selection_is_current(
+                        request_id, generation
+                    ):
                         self._queued_file_selectors.append((payload, generation))
                 continue
             channel.send(json.dumps(payload))

From de0fdbf8fc498669b122db874b823e1b68cf7686 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 12:54:28 -0700
Subject: [PATCH 15/43] Complete every file pick through the shared gate,
 including failed choosers.

Linux chooser errors, a WebRTC POST that never emits, and mp4/null completions now claim the slot before reporting unavailable so a later reuse of the id cannot stall.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  4 +-
 .../flashdreams/api_v2/client_window.py       | 16 ++---
 flashdreams/flashdreams/api_v2/loop.py        |  9 ++-
 .../runtime_v2/mp4_client_window.py           | 21 ++++---
 .../runtime_v2/native_window_client_window.py | 14 ++++-
 .../runtime_v2/null_client_window.py          | 21 ++++---
 .../runtime_v2/serving/webrtc_server.py       | 63 +++++++++++--------
 .../runtime_v2/user_input_event.py            |  2 +-
 .../test_native_window_client_window.py       | 19 ++++++
 .../test_v2/test_webrtc_client_window.py      | 20 ++++++
 integrations_v2/imgui_ui_demo/README.md       |  2 +-
 .../imgui_ui_demo/file_picker_app.py          |  4 +-
 12 files changed, 138 insertions(+), 57 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index e7f96edc6..4be1ca42f 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -237,7 +237,9 @@ outcome (`ok`, `cancelled`, `too_large`, `disallowed_type`, `unavailable`);
 control while a picker is opening are ignored. A new id on every click is
 a new control and queues another dialog. Distinct controls use distinct
 ids and are served one client dialog at a time. Every accepted request later
-produces one event. `cancelled` is only a user dismiss. If the interactive
+produces one event. `cancelled` is only a user dismiss. `unavailable` is a
+pick that could not complete: no interactive client, a gone client, a failed
+chooser, a missing upload, or an unreadable file. If the interactive
 client is gone while the session continues (dropped WebRTC peer, closed native
 window), leftovers complete as `unavailable`. In-flight picks are dropped the
 same way. A picker that outlives that client cannot complete a later request that
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index c555e546d..fb88d6e98 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -72,13 +72,15 @@ def request_selected_files(
         A new id on every click is a new control and queues another dialog.
         A different ``request_id`` waits until the active selector completes,
         so two controls still run one dialog at a time. Every accepted request
-        later produces one event. ``cancelled`` is only a user dismiss. If the
-        interactive client is gone while the session continues (dropped WebRTC
-        peer, closed native window), leftovers complete as ``unavailable``.
-        In-flight picks are dropped the same way. A picker that outlives that
-        client cannot complete a later request that reused the id. Window
-        ``close`` / session replacement finish leftovers without delivering
-        them to the next session.
+        later produces one event. ``cancelled`` is only a user dismiss.
+        ``unavailable`` is a pick that could not complete: no interactive
+        client, a gone client, a failed chooser, a missing upload, or an
+        unreadable file. If the interactive client is gone while the session
+        continues (dropped WebRTC peer, closed native window), leftovers
+        complete as ``unavailable``. In-flight picks are dropped the same way.
+        A picker that outlives that client cannot complete a later request that
+        reused the id. Window ``close`` / session replacement finish leftovers
+        without delivering them to the next session.
 
         Args:
             request_id: Stable id for this selector slot, typically one per
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 170b7afa8..6f267b02c 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -565,9 +565,12 @@ def request_selected_files(
         picker is opening are ignored; two controls use two ids and are served
         in order. A new id on every click is a new control and queues another
         dialog. Every accepted request later produces one event. ``cancelled``
-        is only a user dismiss. If the interactive client is gone while the
-        session continues (dropped WebRTC peer, closed native window), leftovers
-        complete as ``unavailable``. In-flight picks are dropped the same way.
+        is only a user dismiss. ``unavailable`` is a pick that could not
+        complete: no interactive client, a gone client, a failed chooser, a
+        missing upload, or an unreadable file. If the interactive client is
+        gone while the session continues (dropped WebRTC peer, closed native
+        window), leftovers complete as ``unavailable``. In-flight picks are
+        dropped the same way.
         A picker that outlives that client cannot complete a later request that
         reused the id.
 
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index 0705927d1..f2dbb6e63 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -83,14 +83,19 @@ def request_selected_files(
             )
         )
         while started is not None:
-            self._pending_events.append(
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id=started.request_id,
-                    status=SelectedFilesStatus.UNAVAILABLE,
-                )
+            claimed, nxt = self._file_gate.complete(
+                started.request_id, started.generation
             )
-            _, started = self._file_gate.complete(started.request_id)
+            if claimed:
+                self._pending_events.append(
+                    SelectedFilesUserInputEvent(
+                        timestamp=uint64(0),
+                        request_id=started.request_id,
+                        status=SelectedFilesStatus.UNAVAILABLE,
+                        generation=started.generation,
+                    )
+                )
+            started = nxt
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the MP4 presentation dimensions without replacing the session.
@@ -107,6 +112,8 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def open(self, session_desc: SessionDesc) -> None:
         """Prepare to write a session's output."""
+        self._file_gate.clear()
+        self._pending_events.clear()
         self._video_sink.open(session_desc)
 
     def write(self, result: StepResult) -> None:
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 85912fb50..5ff538fd0 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -55,7 +55,11 @@
 
 
 def _ask_open_filename(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-    """Return a path from the OS file picker, or ``""`` when cancelled."""
+    """Return a path from the OS file picker, or ``""`` when cancelled.
+
+    Raises:
+        RuntimeError: The desktop chooser is missing or failed.
+    """
     if sys.platform.startswith("linux"):
         return _ask_open_filename_linux(initial_dir=initial_dir, accept=accept)
     return _ask_open_filename_tkinter(initial_dir=initial_dir, accept=accept)
@@ -100,8 +104,14 @@ def _ask_open_filename_linux(*, initial_dir: str, accept: tuple[str, ...] = ())
         capture_output=True,
         text=True,
     )
-    if completed.returncode != 0:
+    if completed.returncode == 1:
         return ""
+    if completed.returncode != 0:
+        detail = (completed.stderr or completed.stdout or "").strip()
+        raise RuntimeError(
+            f"Native file picker failed with exit {completed.returncode}"
+            + (f": {detail}" if detail else ".")
+        )
     return completed.stdout.strip()
 
 
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index 32d215a68..6d3b04fac 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -65,18 +65,25 @@ def request_selected_files(
             )
         )
         while started is not None:
-            self._pending_events.append(
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id=started.request_id,
-                    status=SelectedFilesStatus.UNAVAILABLE,
-                )
+            claimed, nxt = self._file_gate.complete(
+                started.request_id, started.generation
             )
-            _, started = self._file_gate.complete(started.request_id)
+            if claimed:
+                self._pending_events.append(
+                    SelectedFilesUserInputEvent(
+                        timestamp=uint64(0),
+                        request_id=started.request_id,
+                        status=SelectedFilesStatus.UNAVAILABLE,
+                        generation=started.generation,
+                    )
+                )
+            started = nxt
 
     def open(self, session_desc: SessionDesc) -> None:
         """Accept a session without opening an output."""
         del session_desc
+        self._file_gate.clear()
+        self._pending_events.clear()
 
     def write(self, result: StepResult) -> None:
         """Discard one result."""
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index c5d371ad5..e8121ac96 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -953,10 +953,13 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
                 reason="No pending file selection for this request_id."
             )
 
+        emitted = False
+
         def emit(
             status: SelectedFilesStatus,
             files: tuple[SelectedFile, ...] = (),
         ) -> None:
+            nonlocal emitted
             if not self._file_selection_is_current(request_id, policy.generation):
                 raise web.HTTPConflict(
                     reason="No pending file selection for this request_id."
@@ -968,35 +971,43 @@ def emit(
                 files=files,
                 generation=policy.generation,
             )
+            emitted = True
 
         try:
-            post = await request.post()
-        except web.HTTPRequestEntityTooLarge:
-            emit(SelectedFilesStatus.TOO_LARGE)
-            raise
-        upload = post.get("file")
-        if not isinstance(upload, FileField):
-            emit(SelectedFilesStatus.UNAVAILABLE)
-            raise web.HTTPBadRequest(reason="File upload requires a file.")
-        data = upload.file.read()
-        name = upload.filename or "upload"
-        rejected = selected_file_policy_status(
-            name, len(data), accept=policy.accept, max_bytes=policy.max_bytes
-        )
-        if rejected is SelectedFilesStatus.DISALLOWED_TYPE:
-            emit(rejected)
-            return web.Response(status=204)
-        if rejected is SelectedFilesStatus.TOO_LARGE:
-            emit(rejected)
-            raise web.HTTPRequestEntityTooLarge(
-                max_size=policy.max_bytes,
-                actual_size=len(data),
+            try:
+                post = await request.post()
+            except web.HTTPRequestEntityTooLarge:
+                emit(SelectedFilesStatus.TOO_LARGE)
+                raise
+            upload = post.get("file")
+            if not isinstance(upload, FileField):
+                emit(SelectedFilesStatus.UNAVAILABLE)
+                raise web.HTTPBadRequest(reason="File upload requires a file.")
+            data = upload.file.read()
+            name = upload.filename or "upload"
+            rejected = selected_file_policy_status(
+                name, len(data), accept=policy.accept, max_bytes=policy.max_bytes
             )
-        emit(
-            SelectedFilesStatus.OK,
-            files=(SelectedFile(name=name, data=data),),
-        )
-        return web.Response(status=204)
+            if rejected is SelectedFilesStatus.DISALLOWED_TYPE:
+                emit(rejected)
+                return web.Response(status=204)
+            if rejected is SelectedFilesStatus.TOO_LARGE:
+                emit(rejected)
+                raise web.HTTPRequestEntityTooLarge(
+                    max_size=policy.max_bytes,
+                    actual_size=len(data),
+                )
+            emit(
+                SelectedFilesStatus.OK,
+                files=(SelectedFile(name=name, data=data),),
+            )
+            return web.Response(status=204)
+        finally:
+            if not emitted:
+                try:
+                    emit(SelectedFilesStatus.UNAVAILABLE)
+                except web.HTTPConflict:
+                    pass
 
     async def _offer(self, request: web.Request) -> web.Response:
         """Negotiate one browser peer connection."""
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index efb75b11d..8e786a487 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -315,7 +315,7 @@ class SelectedFilesStatus(Enum):
     """The chosen file did not match ``accept``. Checked before size."""
 
     UNAVAILABLE = "unavailable"
-    """The picker could not complete: headless output, a gone client, or an unreadable file."""
+    """The picker could not complete: headless output, a gone client, a failed chooser, a missing upload, or an unreadable file."""
 
 
 def selected_file_policy_status(
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 5eaae0973..1c706f792 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -918,6 +918,25 @@ def test_ask_open_filename_linux_cancel_is_empty(
     assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == ""
 
 
+def test_ask_open_filename_linux_error_raises(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+    monkeypatch.setattr(
+        native_window_module.subprocess,
+        "run",
+        lambda argv, **kwargs: SimpleNamespace(
+            returncode=5, stdout="", stderr="no display"
+        ),
+    )
+    with pytest.raises(RuntimeError, match="exit 5"):
+        native_window_module._ask_open_filename_linux(initial_dir="/tmp")
+
+
 def test_native_window_reports_standard_gamepad_events() -> None:
     presenter = _Presenter()
     clock_values = iter((1_000_000, 1_001_000, 1_002_000, 1_003_000))
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 7816cd222..dbe5effbf 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -467,6 +467,26 @@ async def test_file_upload_rejects_disallowed_suffix() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_file_upload_without_file_is_unavailable() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files("open-1")
+        await _wait_file_armed(window, "open-1")
+        form = FormData()
+        form.add_field("not_file", "hello")
+        async with ClientSession() as client:
+            async with client.post(_files_url(window, "open-1"), data=form) as response:
+                assert response.status == 400
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+        assert event.files == ()
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_file_upload_rejects_oversize() -> None:
     window = WebRTCClientWindow()
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index 5de22a4e9..d7ec3161e 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -13,7 +13,7 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
   Each Open control uses a stable `request_id`. Extra clicks on the same
   control while a picker is open are ignored; **Open A then B** queues both
   selectors one at a time. Closing the native window or dropping the WebRTC
-  tab completes leftover picks as unavailable.
+  tab completes leftover and in-flight picks as unavailable.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 19763c24e..5869c2724 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -46,8 +46,8 @@
         "SelectedFilesStatus.DISALLOWED_TYPE: suffix not in accept=('.bin', '.raw')."
     ),
     SelectedFilesStatus.UNAVAILABLE: (
-        "SelectedFilesStatus.UNAVAILABLE: picker did not run "
-        "(--mode mp4 or null, dropped WebRTC peer, or unreadable path / OSError)."
+        "SelectedFilesStatus.UNAVAILABLE: picker could not complete "
+        "(no interactive client, gone client, failed chooser, or unreadable file)."
     ),
 }
 _FILE_SELECTION_ERROR_COLOR = (1.0, 0.25, 0.25, 1.0)

From 9139b9a4b706e9a7970390990d8f14dfe10757fb Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 12:55:11 -0700
Subject: [PATCH 16/43] Drop leftover native file picks when a replacement
 session reopens the window.

Main now reuses the GLFW presenter across sessions, so open() must drain the shared gate the same way WebRTC does.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 .../runtime_v2/native_window_client_window.py |  4 ++-
 .../test_native_window_client_window.py       | 35 +++++++++++++++++++
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 549fc6aba..8d8aa1ae4 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -402,7 +402,8 @@ def open(self, session_desc: SessionDesc) -> None:
         """Open a session in the GLFW window on the runtime's UI thread.
 
         Replacement sessions reuse the existing presenter and clear input
-        buffered for the completed session.
+        buffered for the completed session. Leftover and in-flight file picks
+        are dropped rather than delivered to the replacement.
 
         Args:
             session_desc: Resolved output dimensions and tensor layout.
@@ -437,6 +438,7 @@ def open(self, session_desc: SessionDesc) -> None:
                 presenter.close()
                 raise
 
+        self._invalidate_file_selections(deliver_unavailable=False)
         self._session_started_ns = self._clock_ns()
         self._session_desc = session_desc
         self._window_size = presenter.size
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index e79c082ce..f2d92f67a 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -826,6 +826,41 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     assert isinstance(events[-1], CloseUserInputEvent)
 
 
+def test_native_window_replacement_open_drops_leftover_file_selections(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    entered = threading.Event()
+    released = threading.Event()
+    calls: list[int] = []
+
+    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+        del initial_dir, accept
+        calls.append(1)
+        entered.set()
+        assert released.wait(timeout=2.0)
+        return str(tmp_path / "late.bin")
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files("open-2", str(tmp_path))
+    assert entered.wait(timeout=2.0)
+    window.open(_session_desc())
+    events = window.get_user_input_events().get_events()
+    released.set()
+    time.sleep(0.05)
+    extra = window.get_user_input_events().get_events()
+    window.close()
+
+    assert events == []
+    assert extra == []
+    assert calls == [1]
+
+
 def test_native_window_stale_picker_does_not_complete_reused_request_id(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

From 6502aa854e8a0677799defceba751c2238b93408 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 16:50:59 -0700
Subject: [PATCH 17/43] Drop duplicate file-selection tests that rechecked the
 same contract.

Keep one headless queued case, fold WebRTC mash into one-at-a-time, and parametrize the demo Open A/B buttons.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/test_v2/test_selected_files.py    | 51 +++----------------
 .../test_v2/test_webrtc_client_window.py      | 46 +----------------
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py | 29 ++++-------
 3 files changed, 18 insertions(+), 108 deletions(-)

diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 38e322adc..4e77a4aad 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -129,17 +129,6 @@ def test_file_selection_gate_ignores_duplicates_and_serves_one_at_a_time() -> No
     assert gate.complete("open-2") == (True, None)
 
 
-def test_file_selection_gate_clear_drops_queued_requests() -> None:
-    gate = FileSelectionGate()
-    assert gate.submit(_queued("open-1")) is not None
-    assert gate.submit(_queued("open-2")) is None
-    gate.clear()
-    assert gate.complete("open-1") == (False, None)
-    started = gate.submit(_queued("open-2"))
-    assert started is not None
-    assert started.request_id == "open-2"
-
-
 def test_file_selection_gate_drain_returns_active_then_queued() -> None:
     gate = FileSelectionGate()
     assert gate.submit(_queued("open-1")) is not None
@@ -220,42 +209,13 @@ def test_selected_files_event_rejects_inconsistent_status() -> None:
         )
 
 
-def test_mp4_window_completes_file_selection_as_unavailable(tmp_path: Path) -> None:
-    window = Mp4ClientWindow(tmp_path / "clip.mp4")
-    window.request_selected_files("open-1", "/tmp")
-
-    events = window.get_user_input_events().get_events()
-
-    assert len(events) == 1
-    event = events[0]
-    assert isinstance(event, SelectedFilesUserInputEvent)
-    assert event.request_id == "open-1"
-    assert event.status is SelectedFilesStatus.UNAVAILABLE
-    assert event.files == ()
-    assert window.get_user_input_events().get_events() == []
-
-
-def test_mp4_window_completes_queued_file_selections_as_unavailable(
-    tmp_path: Path,
+@pytest.mark.parametrize("kind", ["mp4", "null"])
+def test_headless_window_completes_queued_file_selections_as_unavailable(
+    kind: str, tmp_path: Path
 ) -> None:
-    window = Mp4ClientWindow(tmp_path / "clip.mp4")
-    window.request_selected_files("open-1", "/tmp")
-    window.request_selected_files("open-2", "/var")
-
-    events = window.get_user_input_events().get_events()
-
-    picks = [
-        event for event in events if isinstance(event, SelectedFilesUserInputEvent)
-    ]
-    assert [event.request_id for event in picks] == ["open-1", "open-2"]
-    assert all(
-        event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
-        for event in picks
+    window = (
+        Mp4ClientWindow(tmp_path / "clip.mp4") if kind == "mp4" else NullClientWindow()
     )
-
-
-def test_null_window_completes_file_selection_as_unavailable() -> None:
-    window = NullClientWindow()
     window.request_selected_files("open-1", "/tmp")
     window.request_selected_files("open-2", "/var")
 
@@ -269,3 +229,4 @@ def test_null_window_completes_file_selection_as_unavailable() -> None:
         event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
         for event in picks
     )
+    assert window.get_user_input_events().get_events() == []
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index dbe5effbf..684122aec 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -174,39 +174,12 @@ async def test_browser_query_string_reaches_the_input_stream() -> None:
         window.close()
 
 
-@pytest.mark.asyncio
-async def test_browser_file_upload_reaches_the_input_stream() -> None:
-    window = WebRTCClientWindow()
-    window.open(_session_desc())
-    try:
-        window.request_selected_files("open-1", "/tmp")
-        window.request_selected_files("open-1", "/tmp")
-        await _wait_file_armed(window, "open-1")
-
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
-
-        events = []
-        for _ in range(100):
-            events.extend(window.get_user_input_events().get_events())
-            if events:
-                break
-            await asyncio.sleep(0.01)
-        assert len(events) == 1
-        event = events[0]
-        assert isinstance(event, SelectedFilesUserInputEvent)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.OK
-        assert event.files[0].name == "hello.txt"
-        assert event.files[0].data == b"hello"
-    finally:
-        window.close()
-
-
 @pytest.mark.asyncio
 async def test_browser_file_selections_are_served_one_at_a_time() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
+        window.request_selected_files("open-1", "/tmp")
         window.request_selected_files("open-1", "/tmp")
         window.request_selected_files("open-2", "/tmp")
         await _wait_file_armed(window, "open-1")
@@ -229,6 +202,7 @@ async def test_browser_file_selections_are_served_one_at_a_time() -> None:
         ]
         assert [event.request_id for event in picks] == ["open-1", "open-2"]
         assert all(event.status is SelectedFilesStatus.OK for event in picks)
+        assert picks[0].files[0].name == "first.txt"
         assert picks[0].files[0].data == b"first"
         assert picks[1].files[0].data == b"second"
     finally:
@@ -451,22 +425,6 @@ async def _wait_selected_files_event(
     return event
 
 
-@pytest.mark.asyncio
-async def test_file_upload_rejects_disallowed_suffix() -> None:
-    window = WebRTCClientWindow()
-    window.open(_session_desc())
-    try:
-        window.request_selected_files("open-1", accept=(".png",))
-        await _wait_file_armed(window, "open-1")
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
-        event = await _wait_selected_files_event(window)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.DISALLOWED_TYPE
-        assert event.files == ()
-    finally:
-        window.close()
-
-
 @pytest.mark.asyncio
 async def test_file_upload_without_file_is_unavailable() -> None:
     window = WebRTCClientWindow()
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index b28283623..42a35bbda 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -102,18 +102,23 @@ def _file_picker_imgui(*, pressed: str | tuple[str, ...] = ()) -> SimpleNamespac
     )
 
 
-def test_open_file_button_requests_a_client_file() -> None:
+@pytest.mark.parametrize(
+    ("label", "request_id"),
+    [
+        (_OPEN_FILE_A_LABEL, _OPEN_FILE_A_REQUEST_ID),
+        (_OPEN_FILE_B_LABEL, _OPEN_FILE_B_REQUEST_ID),
+    ],
+)
+def test_open_file_button_requests_a_client_file(label: str, request_id: str) -> None:
     _state, loop = _file_picker_loop()
-    imgui = _file_picker_imgui(pressed=_OPEN_FILE_A_LABEL)
+    imgui = _file_picker_imgui(pressed=label)
 
     loop.step_ui(imgui, 0, UserInputEvents([]))
     loop.step_ui(imgui, 1, UserInputEvents([]))
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == [
-        _OPEN_FILE_A_REQUEST_ID
-    ]
+    assert [item.request_id for item in requests.file_selections] == [request_id]
     assert requests.file_selections[0].accept == (".bin", ".raw")
     assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
 
@@ -132,20 +137,6 @@ def test_open_a_then_b_queues_both_request_ids() -> None:
     ]
 
 
-def test_two_file_buttons_queue_distinct_request_ids() -> None:
-    _state, loop = _file_picker_loop()
-    imgui = _file_picker_imgui(pressed=(_OPEN_FILE_A_LABEL, _OPEN_FILE_B_LABEL))
-
-    loop.step_ui(imgui, 0, UserInputEvents([]))
-    requests = loop.flush_ui_loop_requests()
-
-    assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == [
-        _OPEN_FILE_A_REQUEST_ID,
-        _OPEN_FILE_B_REQUEST_ID,
-    ]
-
-
 def test_selected_files_event_updates_file_picker_status() -> None:
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()

From b82b603a8db212668ccce85d865f1af466f3818e Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Fri, 2 Oct 2026 17:14:37 -0700
Subject: [PATCH 18/43] Call the WebRTC file prompt a request to select, not
 open.

The extra click only arms the browser chooser. "Open a file" read as the app opening something.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/runtime_v2/serving/web/app.js     | 4 ++--
 flashdreams/flashdreams/runtime_v2/serving/web/index.html | 2 +-
 flashdreams/test_v2/test_webrtc_client_window.py          | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index ad7c572d3..89b2343c4 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -349,7 +349,7 @@ const openFileSelector = options => {
     maxBytes: Number.isFinite(maxBytes) ? maxBytes : 0,
   };
   showPromptDialog({
-    title: "The app wants to open a file",
+    title: "The app requested a file",
     details: [
       {
         label: "Accepted types",
@@ -360,7 +360,7 @@ const openFileSelector = options => {
         items: [formatByteBudget(pendingFileRequest.maxBytes)],
       },
     ],
-    confirmLabel: "Open",
+    confirmLabel: "Select…",
     onConfirm: () => {
       const pending = pendingFileRequest;
       if (pending === null || pending.id !== requestId) {
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/index.html b/flashdreams/flashdreams/runtime_v2/serving/web/index.html
index a7114767f..eb0d4ad2c 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/index.html
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/index.html
@@ -159,7 +159,7 @@ <h2 id="prompt-dialog-title"></h2>
       <div id="prompt-dialog-details" hidden></div>
       <div class="prompt-dialog-actions">
         <button type="button" id="prompt-dialog-cancel">Cancel</button>
-        <button type="button" id="prompt-dialog-confirm">Open</button>
+        <button type="button" id="prompt-dialog-confirm">Select…</button>
       </div>
     </dialog>
     <script src="/app.js"></script>
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 684122aec..b9f50d417 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -664,7 +664,7 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert "selectedFilePolicyStatus" in browser_script
                 assert "showPromptDialog" in browser_script
                 assert "showModal" not in browser_script
-                assert "The app wants to open a file" in browser_script
+                assert "The app requested a file" in browser_script
                 assert 'label: "Accepted types"' in browser_script
                 assert 'label: "Max size allowed"' in browser_script
                 assert "Choose file" not in browser_page

From 5e47b09194566c0cf5800651721387921b897f04 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 5 Oct 2026 13:43:29 -0700
Subject: [PATCH 19/43] Keep request_id as the app-owned button id and let apps
 pick multiple files.

Windows take FileSelectionRequest; selected-file types move out of the event module. WebRTC copy and the demo overlay follow.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  31 +--
 .../flashdreams/api_v2/client_window.py       |  48 +---
 flashdreams/flashdreams/api_v2/loop.py        |  75 ++----
 .../runtime_v2/file_selection_gate.py         |  26 ++-
 .../runtime_v2/mp4_client_window.py           |  37 +--
 .../runtime_v2/native_window_client_window.py | 214 +++++++++++-------
 .../runtime_v2/null_client_window.py          |  36 +--
 .../flashdreams/runtime_v2/selected_file.py   | 193 ++++++++++++++++
 .../flashdreams/runtime_v2/serving/web/app.js |  50 ++--
 .../runtime_v2/serving/webrtc_server.py       |  75 ++++--
 .../flashdreams/runtime_v2/session_runner.py  |   7 +-
 .../runtime_v2/user_input_event.py            | 134 +----------
 .../runtime_v2/webrtc_client_window.py        |  44 +---
 .../test_native_window_client_window.py       | 209 ++++++++++++-----
 flashdreams/test_v2/test_selected_files.py    |  67 +++++-
 flashdreams/test_v2/test_session_runner.py    |  29 ++-
 .../test_v2/test_webrtc_client_window.py      | 104 +++++++--
 integrations_v2/imgui_ui_demo/README.md       |   5 +-
 .../imgui_ui_demo/file_picker_app.py          |  22 +-
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  51 ++++-
 20 files changed, 886 insertions(+), 571 deletions(-)
 create mode 100644 flashdreams/flashdreams/runtime_v2/selected_file.py

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 4be1ca42f..c93e9f7dd 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -223,27 +223,16 @@ exposes `imgui_bundle.imgui` and an image-like pixel upload convenience form. A
 UI control that needs a fresh application session calls
 `request_new_session(session_desc)` with a fully resolved replacement
 description; the runtime cleans the current session and passes that description
-to `ApplicationRunner` unchanged. A control that needs a file from the client
-calls `request_selected_files(request_id, accept=..., max_bytes=...)`; the
-window later reports `SelectedFilesUserInputEvent` through the same input
-stream as keyboard and mouse. ``accept`` (filename suffixes such as ``.png``)
-and ``max_bytes`` are the application's policy; windows classify the choice
-with `selected_file_policy_status` (type before size) and clamp size to 32 MiB
-so a client cannot raise the cap. Empty ``accept`` (the default) allows any
-type; omit ``max_bytes`` to use the 32 MiB ceiling. Read ``status`` for the
-outcome (`ok`, `cancelled`, `too_large`, `disallowed_type`, `unavailable`);
-``files`` is non-empty only on `ok`. Give each UI control a stable
-`request_id` and reuse it after the matching event: extra clicks on that
-control while a picker is opening are ignored. A new id on every click is
-a new control and queues another dialog. Distinct controls use distinct
-ids and are served one client dialog at a time. Every accepted request later
-produces one event. `cancelled` is only a user dismiss. `unavailable` is a
-pick that could not complete: no interactive client, a gone client, a failed
-chooser, a missing upload, or an unreadable file. If the interactive
-client is gone while the session continues (dropped WebRTC peer, closed native
-window), leftovers complete as `unavailable`. In-flight picks are dropped the
-same way. A picker that outlives that client cannot complete a later request that
-reused the id.
+to `ApplicationRunner` unchanged. A control that needs a file from the client calls
+`request_selected_files(request_id, accept=..., max_bytes=..., multiple=...)`.
+The window later reports `SelectedFilesUserInputEvent` on the same input stream
+as keyboard and mouse. Read `status`; use `files` only when the pick succeeded.
+`request_id` is a stable id for which button made the request and is
+echoed on that event. Reuse it every time that button is pressed so a
+second click is the same request, not another picker; use a different
+id for a different button. `accept` is filename suffixes (empty = any type);
+`max_bytes` is the size budget per file (`None` = the 32 MiB ceiling);
+`multiple` allows more than one file.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index fb88d6e98..50944d012 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -4,7 +4,8 @@
 """Client window abstract interface."""
 
 from abc import ABC
-from collections.abc import Sequence
+
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 
 from .input_source import InputSource
 from .output_sink import OutputSink
@@ -49,45 +50,14 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         pass
 
     # Optional to implement
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-    ) -> None:
-        """Ask this client to pick files and report them as input events.
-
-        The chosen files arrive later through
-        :meth:`InputSource.get_user_input_events`. Windows classify the choice
-        with
-        :func:`~flashdreams.runtime_v2.user_input_event.selected_file_policy_status`
-        (type before size) and clamp size to the 32 MiB ceiling. The event
-        carries a ``status`` so cancel, oversize, and disallowed type are
-        distinct. Applications read that ``status``; they do not re-check type
-        or size. A second call with the same ``request_id`` while the first is
-        still active or queued is ignored. Use one stable id per UI control so
-        extra clicks while the picker is opening do not enqueue more dialogs.
-        A new id on every click is a new control and queues another dialog.
-        A different ``request_id`` waits until the active selector completes,
-        so two controls still run one dialog at a time. Every accepted request
-        later produces one event. ``cancelled`` is only a user dismiss.
-        ``unavailable`` is a pick that could not complete: no interactive
-        client, a gone client, a failed chooser, a missing upload, or an
-        unreadable file. If the interactive client is gone while the session
-        continues (dropped WebRTC peer, closed native window), leftovers
-        complete as ``unavailable``. In-flight picks are dropped the same way.
-        A picker that outlives that client cannot complete a later request that
-        reused the id. Window ``close`` / session replacement finish leftovers
-        without delivering them to the next session.
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        """Request to open a file selector local to the client this window drives.
+
+        The result arrives later through
+        :meth:`InputSource.get_user_input_events` as
+        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
 
         Args:
-            request_id: Stable id for this selector slot, typically one per
-                UI control. Reuse it after the matching event arrives.
-            initial_path: Directory the selector should start in; ``None`` lets
-                the window choose a default.
-            accept: Filename suffixes such as ``.png``. Empty allows any type.
-            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
+            request: Selector request queued by the UI loop.
         """
         pass
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 6f267b02c..ad1a22f9e 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -21,10 +21,13 @@
 
 from flashdreams.runtime_v2.event_buffer import EventBuffer
 from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    normalize_selected_file_accept,
+)
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
     UserInputEvent,
-    normalize_selected_file_accept,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
@@ -77,23 +80,6 @@ class _Message(Generic[StateT]):
     """Operation to run before the loop's next step."""
 
 
-@dataclass(frozen=True, slots=True)
-class FileSelectionRequest:
-    """One client file-selector request queued by a UI loop."""
-
-    request_id: str
-    """Stable selector-slot id from the UI control that asked for a file."""
-
-    initial_path: str
-    """Directory the selector should start in."""
-
-    accept: tuple[str, ...] = ()
-    """Filename suffixes the client may choose, empty for any type."""
-
-    max_bytes: int | None = None
-    """Requested size budget in bytes, or ``None`` for the window ceiling."""
-
-
 @dataclass(slots=True)
 class UILoopRequests:
     """Changes requested by a UI loop for the session runtime to apply.
@@ -551,46 +537,30 @@ def request_selected_files(
         *,
         accept: Sequence[str] = (),
         max_bytes: int | None = None,
+        multiple: bool = False,
     ) -> None:
-        """Ask the client window to open a file selector.
-
-        The window reports the result later as
-        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
-        Read ``status`` for cancel, oversize, disallowed type, or unavailable;
-        ``files`` is non-empty only when the pick succeeded. A second call with
-        the same ``request_id`` while the first is still active or queued is
-        ignored so the original picker can still complete. Distinct ids are
-        forwarded in order; the window shows one client selector at a time.
-        Use one stable ``request_id`` per UI control so extra clicks while the
-        picker is opening are ignored; two controls use two ids and are served
-        in order. A new id on every click is a new control and queues another
-        dialog. Every accepted request later produces one event. ``cancelled``
-        is only a user dismiss. ``unavailable`` is a pick that could not
-        complete: no interactive client, a gone client, a failed chooser, a
-        missing upload, or an unreadable file. If the interactive client is
-        gone while the session continues (dropped WebRTC peer, closed native
-        window), leftovers complete as ``unavailable``. In-flight picks are
-        dropped the same way.
-        A picker that outlives that client cannot complete a later request that
-        reused the id.
-
-        ``accept`` and ``max_bytes`` are the application's policy. Windows
-        classify the choice with
-        :func:`~flashdreams.runtime_v2.user_input_event.selected_file_policy_status`
-        (type before size) and clamp ``max_bytes`` to the 32 MiB ceiling so a
-        client cannot raise the cap.
+        """Request that the client window open a file selector local to the client.
+
+        The result arrives later as
+        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`
+        with this ``request_id``. Read ``status`` to see whether the pick
+        succeeded; use ``files`` only when it did.
 
         Args:
-            request_id: Stable id for this selector slot, typically one per
-                UI control. Reuse it after the matching event arrives.
-            initial_path: Directory the selector should start in; ``None`` uses
-                the current user's home directory.
+            request_id: Stable id for which button this request is for. Reuse
+                it every time that button is pressed so a second click is the
+                same request, not another picker. Use a different id for a
+                different button so the later event can be told apart.
+            initial_path: Directory hint for the selector; ``None`` uses the
+                current user's home directory.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
-            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
+            max_bytes: Maximum size of each file in bytes, or ``None`` for the
+                ceiling.
+            multiple: Whether the selector may return more than one file.
 
         Raises:
             TypeError: ``request_id`` or ``initial_path`` is not a string, or
-                ``accept`` / ``max_bytes`` has the wrong type.
+                ``accept`` / ``max_bytes`` / ``multiple`` has the wrong type.
             ValueError: ``request_id`` is empty, ``initial_path`` is empty, or
                 ``accept`` / ``max_bytes`` is invalid.
         """
@@ -612,6 +582,8 @@ def request_selected_files(
                 raise TypeError("max_bytes must be an integer.")
             if max_bytes <= 0:
                 raise ValueError("max_bytes must be > 0.")
+        if not isinstance(multiple, bool):
+            raise TypeError("multiple must be a bool.")
         requests = self.get_or_create_ui_loop_requests()
         if any(
             selection.request_id == request_id for selection in requests.file_selections
@@ -627,6 +599,7 @@ def request_selected_files(
                 initial_path=resolved_initial_path,
                 accept=suffixes,
                 max_bytes=max_bytes,
+                multiple=multiple,
             )
         )
 
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
index 0e317a67c..c72f5f150 100644
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -10,15 +10,17 @@
 from collections import deque
 from dataclasses import dataclass, replace
 
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
+
 _LOGGER = logging.getLogger(__name__)
 
 
 @dataclass(frozen=True, slots=True)
 class QueuedFileSelection:
-    """One file-selector request waiting to occupy the client dialog."""
+    """One file-selector request waiting to become active."""
 
     request_id: str
-    """Stable selector-slot id for the later selected-files input event."""
+    """Stable id for which button this request is for."""
 
     initial_path: str | None
     """Directory hint for the selector, or ``None`` for the window default."""
@@ -29,9 +31,23 @@ class QueuedFileSelection:
     max_bytes: int | None
     """Requested size budget in bytes, or ``None`` for the window ceiling."""
 
+    multiple: bool = False
+    """Whether the selector may return more than one file."""
+
     generation: int = 0
     """Client generation that admitted this request. Stale pickers do not match."""
 
+    @classmethod
+    def from_request(cls, request: FileSelectionRequest) -> QueuedFileSelection:
+        """Build a queued selection from a UI-loop request."""
+        return cls(
+            request_id=request.request_id,
+            initial_path=request.initial_path,
+            accept=request.accept,
+            max_bytes=request.max_bytes,
+            multiple=request.multiple,
+        )
+
 
 class FileSelectionGate:
     """Admit one client file selector at a time.
@@ -39,8 +55,8 @@ class FileSelectionGate:
     A duplicate ``request_id`` that is already active or queued is ignored.
     A different id waits until :meth:`complete` for the active request.
     Callers emit a selected-files event only after :meth:`complete` claims
-    the slot. :meth:`drain` finishes the current client generation so a late
-    picker or upload cannot complete a later request that reused the id.
+    the slot. :meth:`drain` finishes the current client generation so late
+    in-flight work cannot complete a later request that reused the id.
     """
 
     def __init__(self) -> None:
@@ -80,7 +96,7 @@ def complete(
         """Claim ``request_id`` if it is still current and return the next start.
 
         Callers emit a result only when this returns ``claimed=True``. Client-gone
-        :meth:`drain` wins the race against in-flight pickers and uploads.
+        :meth:`drain` wins the race against in-flight work.
 
         Args:
             request_id: Id of the in-flight selector.
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index f2dbb6e63..c59a08445 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -3,7 +3,6 @@
 
 """Client window that writes an MP4 file."""
 
-from collections.abc import Sequence
 from pathlib import Path
 
 from numpy import uint64
@@ -14,10 +13,13 @@
     QueuedFileSelection,
 )
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     UserInputEvent,
 )
@@ -56,32 +58,9 @@ def get_user_input_events(self) -> UserInputEvents:
         self._pending_events = []
         return UserInputEvents(events)
 
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-    ) -> None:
-        """Complete a file-selector request as unavailable.
-
-        Overlapping distinct ids are completed in order, each as unavailable.
-
-        Args:
-            request_id: Stable selector-slot id from the UI control.
-            initial_path: Ignored; this window has no selector.
-            accept: Ignored; this window has no selector.
-            max_bytes: Ignored; this window has no selector.
-        """
-        started = self._file_gate.submit(
-            QueuedFileSelection(
-                request_id=request_id,
-                initial_path=initial_path,
-                accept=tuple(accept),
-                max_bytes=max_bytes,
-            )
-        )
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        """Complete a file-selector request as unavailable."""
+        started = self._file_gate.submit(QueuedFileSelection.from_request(request))
         while started is not None:
             claimed, nxt = self._file_gate.complete(
                 started.request_id, started.generation
@@ -92,7 +71,7 @@ def request_selected_files(
                         timestamp=uint64(0),
                         request_id=started.request_id,
                         status=SelectedFilesStatus.UNAVAILABLE,
-                        generation=started.generation,
+                        _generation=started.generation,
                     )
                 )
             started = nxt
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 8d8aa1ae4..e76288cfd 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -7,6 +7,7 @@
 
 import logging
 import queue
+import shlex
 import shutil
 import subprocess
 import sys
@@ -29,21 +30,23 @@
     FileSelectionGate,
     QueuedFileSelection,
 )
+from flashdreams.runtime_v2.selected_file import (
+    MAX_SELECTED_FILE_BYTES,
+    FileSelectionRequest,
+    SelectedFile,
+    SelectedFilesStatus,
+    clamp_selected_file_max_bytes,
+    selected_files_policy_status,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    MAX_SELECTED_FILE_BYTES,
     CloseUserInputEvent,
     GamepadUserInputEvent,
     KeyboardInputState,
     KeyboardUserInputEvent,
     MouseUserInputEvent,
-    SelectedFile,
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
-    clamp_selected_file_max_bytes,
-    normalize_selected_file_accept,
-    selected_file_policy_status,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -54,15 +57,24 @@
 _LOGGER = logging.getLogger(__name__)
 
 
-def _ask_open_filename(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-    """Return a path from the OS file picker, or ``""`` when cancelled.
+def _ask_open_filename(
+    *,
+    initial_dir: str,
+    accept: tuple[str, ...] = (),
+    multiple: bool = False,
+) -> tuple[str, ...]:
+    """Return paths from the OS file picker, or an empty tuple when cancelled.
 
     Raises:
         RuntimeError: The desktop chooser is missing or failed.
     """
     if sys.platform.startswith("linux"):
-        return _ask_open_filename_linux(initial_dir=initial_dir, accept=accept)
-    return _ask_open_filename_tkinter(initial_dir=initial_dir, accept=accept)
+        return _ask_open_filename_linux(
+            initial_dir=initial_dir, accept=accept, multiple=multiple
+        )
+    return _ask_open_filename_tkinter(
+        initial_dir=initial_dir, accept=accept, multiple=multiple
+    )
 
 
 def _accept_filter_patterns(accept: tuple[str, ...]) -> str:
@@ -70,7 +82,12 @@ def _accept_filter_patterns(accept: tuple[str, ...]) -> str:
     return " ".join(f"*{suffix}" for suffix in accept)
 
 
-def _ask_open_filename_linux(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
+def _ask_open_filename_linux(
+    *,
+    initial_dir: str,
+    accept: tuple[str, ...] = (),
+    multiple: bool = False,
+) -> tuple[str, ...]:
     """Open the desktop file picker via ``zenity`` or ``kdialog``.
 
     ``zenity --file-selection`` uses ``GtkFileChooserNative``, which is the
@@ -87,17 +104,31 @@ def _ask_open_filename_linux(*, initial_dir: str, accept: tuple[str, ...] = ())
             f"--filename={directory}/",
             "--title=Select a file",
         ]
+        if multiple:
+            argv.extend(("--multiple", "--separator=\n"))
         if patterns:
             argv.append(f"--file-filter=Accepted | {patterns}")
-    else:
-        kdialog = shutil.which("kdialog")
-        if kdialog is None:
-            raise RuntimeError(
-                "Native file picker needs a desktop chooser (zenity or kdialog)."
-            )
-        argv = [kdialog, "--getopenfilename", directory]
-        if patterns:
-            argv.append(f"Accepted ({patterns})")
+        return _parse_chooser_stdout(
+            _run_desktop_chooser(argv), multiple=multiple, quoted=False
+        )
+    kdialog = shutil.which("kdialog")
+    if kdialog is None:
+        raise RuntimeError(
+            "Native file picker needs a desktop chooser (zenity or kdialog)."
+        )
+    argv = [kdialog, "--getopenfilename"]
+    if multiple:
+        argv.append("--multiple")
+    argv.append(directory)
+    if patterns:
+        argv.append(f"Accepted ({patterns})")
+    return _parse_chooser_stdout(
+        _run_desktop_chooser(argv), multiple=multiple, quoted=True
+    )
+
+
+def _run_desktop_chooser(argv: list[str]) -> subprocess.CompletedProcess[str]:
+    """Run one desktop file chooser and map non-cancel failures to errors."""
     completed = subprocess.run(
         argv,
         check=False,
@@ -105,19 +136,41 @@ def _ask_open_filename_linux(*, initial_dir: str, accept: tuple[str, ...] = ())
         text=True,
     )
     if completed.returncode == 1:
-        return ""
+        return completed
     if completed.returncode != 0:
         detail = (completed.stderr or completed.stdout or "").strip()
         raise RuntimeError(
             f"Native file picker failed with exit {completed.returncode}"
             + (f": {detail}" if detail else ".")
         )
-    return completed.stdout.strip()
+    return completed
+
+
+def _parse_chooser_stdout(
+    completed: subprocess.CompletedProcess[str],
+    *,
+    multiple: bool,
+    quoted: bool,
+) -> tuple[str, ...]:
+    """Return selected paths from a chooser, or ``()`` when cancelled."""
+    if completed.returncode == 1:
+        return ()
+    output = completed.stdout.strip()
+    if not output:
+        return ()
+    if not multiple:
+        return (output,)
+    if quoted:
+        return tuple(shlex.split(output))
+    return tuple(line for line in output.splitlines() if line)
 
 
 def _ask_open_filename_tkinter(
-    *, initial_dir: str, accept: tuple[str, ...] = ()
-) -> str:
+    *,
+    initial_dir: str,
+    accept: tuple[str, ...] = (),
+    multiple: bool = False,
+) -> tuple[str, ...]:
     """Open the Tk file dialog (native Explorer / macOS panel)."""
     import tkinter as tk
     from tkinter import filedialog
@@ -135,41 +188,58 @@ def _ask_open_filename_tkinter(
         }
         if accept:
             kwargs["filetypes"] = [("Accepted", _accept_filter_patterns(accept))]
+        if multiple:
+            selected = filedialog.askopenfilenames(**kwargs)
+            return tuple(str(path) for path in selected if path)
         selected = filedialog.askopenfilename(**kwargs)
     finally:
         root.destroy()
-    return str(selected or "")
+    return (str(selected),) if selected else ()
 
 
-def _selected_file_from_path(
-    path: Path,
+def _selected_files_from_paths(
+    paths: Sequence[str],
     *,
     accept: tuple[str, ...] = (),
     max_bytes: int | None = None,
-) -> tuple[SelectedFile | None, SelectedFilesStatus]:
-    """Load one picked file, or ``None`` and a failure status."""
+) -> tuple[tuple[SelectedFile, ...], SelectedFilesStatus]:
+    """Load chosen files, or empty files and a failure status."""
     budget = MAX_SELECTED_FILE_BYTES if max_bytes is None else max_bytes
-    rejected = selected_file_policy_status(
-        path.name, None, accept=accept, max_bytes=budget
+    rejected = selected_files_policy_status(
+        [(Path(path).name, None) for path in paths],
+        accept=accept,
+        max_bytes=budget,
     )
     if rejected is not None:
-        return None, rejected
-    try:
-        size = path.stat().st_size
-        rejected = selected_file_policy_status(
-            path.name, size, accept=accept, max_bytes=budget
-        )
-        if rejected is not None:
-            return None, rejected
-        data = path.read_bytes()
-    except OSError:
-        return None, SelectedFilesStatus.UNAVAILABLE
-    rejected = selected_file_policy_status(
-        path.name, len(data), accept=accept, max_bytes=budget
+        return (), rejected
+    sized: list[tuple[str, int]] = []
+    for path in paths:
+        try:
+            sized.append((path, Path(path).stat().st_size))
+        except OSError:
+            return (), SelectedFilesStatus.UNAVAILABLE
+    rejected = selected_files_policy_status(
+        [(Path(path).name, size) for path, size in sized],
+        accept=accept,
+        max_bytes=budget,
     )
     if rejected is not None:
-        return None, rejected
-    return SelectedFile(name=path.name, data=data), SelectedFilesStatus.OK
+        return (), rejected
+    files: list[SelectedFile] = []
+    for path, _size in sized:
+        try:
+            data = Path(path).read_bytes()
+        except OSError:
+            return (), SelectedFilesStatus.UNAVAILABLE
+        files.append(SelectedFile(name=Path(path).name, data=data))
+    rejected = selected_files_policy_status(
+        [(chosen.name, len(chosen.data)) for chosen in files],
+        accept=accept,
+        max_bytes=budget,
+    )
+    if rejected is not None:
+        return (), rejected
+    return tuple(files), SelectedFilesStatus.OK
 
 
 _PRINTABLE_KEY_NAMES = {
@@ -299,34 +369,13 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
             )
         self._window_size = presenter.resize(*new_window_size)
 
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-    ) -> None:
-        """Ask the OS file selector and enqueue the chosen file.
-
-        The desktop dialog runs on a worker thread so the UI loop can keep
-        polling and presenting while the picker is open. A second distinct
-        ``request_id`` waits until this picker completes. Closing the window
-        completes leftovers and in-flight picks as unavailable.
-
-        Args:
-            request_id: Stable selector-slot id from the UI control.
-            initial_path: Directory the selector should start in; ``None`` uses
-                the current user's home directory.
-            accept: Filename suffixes such as ``.png``. Empty allows any type.
-            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
-        """
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        """Ask the OS file selector and enqueue the chosen files."""
         started = self._file_gate.submit(
-            QueuedFileSelection(
-                request_id=request_id,
-                initial_path=initial_path or str(Path.home()),
-                accept=normalize_selected_file_accept(accept),
-                max_bytes=clamp_selected_file_max_bytes(max_bytes),
+            replace(
+                QueuedFileSelection.from_request(request),
+                initial_path=request.initial_path or str(Path.home()),
+                max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
             )
         )
         if started is not None:
@@ -344,6 +393,7 @@ def _spawn_file_picker(self, pending: QueuedFileSelection) -> None:
                 pending.max_bytes
                 if pending.max_bytes is not None
                 else MAX_SELECTED_FILE_BYTES,
+                pending.multiple,
             ),
             name="flashdreams-file-picker",
             daemon=True,
@@ -357,13 +407,18 @@ def _complete_file_selection(
         initial_dir: str,
         accept: tuple[str, ...],
         max_bytes: int,
+        multiple: bool,
     ) -> None:
         """Run the OS picker and enqueue a selected-files event."""
         files: tuple[SelectedFile, ...] = ()
         status = SelectedFilesStatus.UNAVAILABLE
         try:
             try:
-                selected = _ask_open_filename(initial_dir=initial_dir, accept=accept)
+                selected = _ask_open_filename(
+                    initial_dir=initial_dir,
+                    accept=accept,
+                    multiple=multiple,
+                )
             except Exception:
                 _LOGGER.exception(
                     "Native file picker failed for request id %r.",
@@ -371,12 +426,13 @@ def _complete_file_selection(
                 )
             else:
                 if selected:
-                    chosen, status = _selected_file_from_path(
-                        Path(selected),
+                    if not multiple:
+                        selected = selected[:1]
+                    files, status = _selected_files_from_paths(
+                        selected,
                         accept=accept,
                         max_bytes=max_bytes,
                     )
-                    files = () if chosen is None else (chosen,)
                 else:
                     status = SelectedFilesStatus.CANCELLED
         finally:
@@ -392,7 +448,7 @@ def _complete_file_selection(
                         request_id=request_id,
                         status=status,
                         files=files,
-                        generation=generation,
+                        _generation=generation,
                     )
                 )
             if nxt is not None and self._presenter is not None:
@@ -630,7 +686,7 @@ def _invalidate_file_selections(self, *, deliver_unavailable: bool) -> None:
                     timestamp=uint64(0),
                     request_id=item.request_id,
                     status=SelectedFilesStatus.UNAVAILABLE,
-                    generation=item.generation,
+                    _generation=item.generation,
                 )
             )
 
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index 6d3b04fac..96056307f 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -3,8 +3,6 @@
 
 """Client window that discards output and reports no input."""
 
-from collections.abc import Sequence
-
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
@@ -12,10 +10,13 @@
     FileSelectionGate,
     QueuedFileSelection,
 )
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     UserInputEvent,
 )
@@ -40,30 +41,9 @@ def get_user_input_events(self) -> UserInputEvents:
         self._pending_events = []
         return UserInputEvents(events)
 
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-    ) -> None:
-        """Complete a file-selector request as unavailable.
-
-        Args:
-            request_id: Stable selector-slot id from the UI control.
-            initial_path: Ignored; this window has no selector.
-            accept: Ignored; this window has no selector.
-            max_bytes: Ignored; this window has no selector.
-        """
-        started = self._file_gate.submit(
-            QueuedFileSelection(
-                request_id=request_id,
-                initial_path=initial_path,
-                accept=tuple(accept),
-                max_bytes=max_bytes,
-            )
-        )
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        """Complete a file-selector request as unavailable."""
+        started = self._file_gate.submit(QueuedFileSelection.from_request(request))
         while started is not None:
             claimed, nxt = self._file_gate.complete(
                 started.request_id, started.generation
@@ -74,7 +54,7 @@ def request_selected_files(
                         timestamp=uint64(0),
                         request_id=started.request_id,
                         status=SelectedFilesStatus.UNAVAILABLE,
-                        generation=started.generation,
+                        _generation=started.generation,
                     )
                 )
             started = nxt
diff --git a/flashdreams/flashdreams/runtime_v2/selected_file.py b/flashdreams/flashdreams/runtime_v2/selected_file.py
new file mode 100644
index 000000000..5f162558c
--- /dev/null
+++ b/flashdreams/flashdreams/runtime_v2/selected_file.py
@@ -0,0 +1,193 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Selected-file types, request policy, and size/type checks."""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import Enum
+
+MAX_SELECTED_FILE_BYTES = 32 * 1024 * 1024
+"""Hard ceiling for one selected file. Windows clamp requested budgets to this."""
+
+# ponytail: 8× the per-file ceiling is the batch cap; raise it or
+# make it per-request if an app needs a larger set in one pick.
+MAX_SELECTED_FILE_BATCH_BYTES = 8 * MAX_SELECTED_FILE_BYTES
+"""Hard ceiling for the total bytes of one selected-files request."""
+
+
+def clamp_selected_file_max_bytes(max_bytes: int | None) -> int:
+    """Return a file-size budget that cannot exceed ``MAX_SELECTED_FILE_BYTES``.
+
+    Args:
+        max_bytes: Requested budget in bytes, or ``None`` for the ceiling.
+
+    Returns:
+        The requested budget when it is below the ceiling, otherwise the ceiling.
+
+    Raises:
+        TypeError: ``max_bytes`` is not ``None`` or an integer.
+        ValueError: ``max_bytes`` is not positive.
+    """
+    if max_bytes is None:
+        return MAX_SELECTED_FILE_BYTES
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int):
+        raise TypeError("max_bytes must be an integer.")
+    if max_bytes <= 0:
+        raise ValueError("max_bytes must be > 0.")
+    return min(max_bytes, MAX_SELECTED_FILE_BYTES)
+
+
+def normalize_selected_file_accept(accept: Sequence[str] = ()) -> tuple[str, ...]:
+    """Return accepted filename suffixes such as ``.png``.
+
+    Args:
+        accept: Suffixes the client may choose. Empty means any type.
+
+    Returns:
+        The suffixes as a tuple, unchanged except for the sequence type.
+
+    Raises:
+        TypeError: ``accept`` is not a sequence of strings.
+        ValueError: A suffix is missing the leading ``.`` or contains a path.
+    """
+    if isinstance(accept, str) or not isinstance(accept, Sequence):
+        raise TypeError("accept must be a sequence of suffixes.")
+    suffixes: list[str] = []
+    for suffix in accept:
+        if not isinstance(suffix, str):
+            raise TypeError("accept suffixes must be strings.")
+        if (
+            not suffix.startswith(".")
+            or suffix == "."
+            or "/" in suffix
+            or "\\" in suffix
+        ):
+            raise ValueError(
+                "accept suffixes must look like ``.png`` and cannot contain a path."
+            )
+        suffixes.append(suffix)
+    return tuple(suffixes)
+
+
+def selected_file_suffix_allowed(name: str, accept: tuple[str, ...]) -> bool:
+    """Return whether ``name`` matches ``accept``.
+
+    Empty ``accept`` allows any name. Comparison is case-insensitive.
+    """
+    if not accept:
+        return True
+    lower = name.lower()
+    return any(lower.endswith(suffix.lower()) for suffix in accept)
+
+
+class SelectedFilesStatus(Enum):
+    """Outcome of one client file-selector request."""
+
+    OK = "ok"
+    """The client chose files that passed type and size checks."""
+
+    CANCELLED = "cancelled"
+    """The user dismissed the selector."""
+
+    TOO_LARGE = "too_large"
+    """The chosen set exceeded the size budget."""
+
+    DISALLOWED_TYPE = "disallowed_type"
+    """A chosen file did not match ``accept``. Checked before size."""
+
+    UNAVAILABLE = "unavailable"
+    """The selector could not complete."""
+
+
+def selected_file_policy_status(
+    name: str,
+    size: int | None,
+    *,
+    accept: tuple[str, ...] = (),
+    max_bytes: int,
+) -> SelectedFilesStatus | None:
+    """Return why one chosen file is rejected, or ``None`` if it is allowed.
+
+    Type is checked before size. A too-large disallowed file is
+    ``DISALLOWED_TYPE``. Pass ``size=None`` to check only the name.
+
+    Args:
+        name: File name to match against ``accept``.
+        size: File size in bytes, or ``None`` to skip the size check.
+        accept: Filename suffixes such as ``.png``. Empty allows any type.
+        max_bytes: Maximum allowed size in bytes.
+
+    Returns:
+        ``DISALLOWED_TYPE``, ``TOO_LARGE``, or ``None`` when the file passes.
+    """
+    if not selected_file_suffix_allowed(name, accept):
+        return SelectedFilesStatus.DISALLOWED_TYPE
+    if size is not None and size > max_bytes:
+        return SelectedFilesStatus.TOO_LARGE
+    return None
+
+
+def selected_files_policy_status(
+    files: Sequence[tuple[str, int | None]],
+    *,
+    accept: tuple[str, ...] = (),
+    max_bytes: int,
+) -> SelectedFilesStatus | None:
+    """Return why a chosen set is rejected, or ``None`` if every file is allowed.
+
+    Type is checked before size, across the whole set.
+
+    Args:
+        files: ``(name, size)`` pairs. ``size`` of ``None`` skips that file's
+            size check and omits it from the batch total.
+        accept: Filename suffixes such as ``.png``. Empty allows any type.
+        max_bytes: Maximum allowed size of each file in bytes.
+
+    Returns:
+        ``DISALLOWED_TYPE``, ``TOO_LARGE``, or ``None`` when the set passes.
+    """
+    for name, _size in files:
+        if not selected_file_suffix_allowed(name, accept):
+            return SelectedFilesStatus.DISALLOWED_TYPE
+    total = 0
+    for _name, size in files:
+        if size is None:
+            continue
+        if size > max_bytes:
+            return SelectedFilesStatus.TOO_LARGE
+        total += size
+    if total > MAX_SELECTED_FILE_BATCH_BYTES:
+        return SelectedFilesStatus.TOO_LARGE
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class SelectedFile:
+    """One file chosen by a client file selector."""
+
+    name: str
+    """File name shown to the application."""
+
+    data: bytes
+    """File contents."""
+
+
+@dataclass(frozen=True, slots=True)
+class FileSelectionRequest:
+    """One client file-selector request queued by a UI loop."""
+
+    request_id: str
+    """Stable id for which button this request is for. Echoed on the matching event."""
+
+    initial_path: str
+    """Directory hint for the selector."""
+
+    accept: tuple[str, ...] = ()
+    """Filename suffixes the client may choose, empty for any type."""
+
+    max_bytes: int | None = None
+    """Requested size budget per file in bytes, or ``None`` for the ceiling."""
+
+    multiple: bool = False
+    """Whether the selector may return more than one file."""
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 89b2343c4..288e8b167 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -259,17 +259,6 @@ const fileNameMatchesAccept = (name, accept) => {
   );
 };
 
-const selectedFilePolicyStatus = (name, size, accept, maxBytes) => {
-  // Same order as selected_file_policy_status: type, then size.
-  if (!fileNameMatchesAccept(name, accept)) {
-    return "disallowed_type";
-  }
-  if (size > maxBytes) {
-    return "too_large";
-  }
-  return null;
-};
-
 const startFileInput = pending => {
   const requestId = pending.id;
   const input = document.createElement("input");
@@ -277,6 +266,7 @@ const startFileInput = pending => {
   if (pending.accept.length > 0) {
     input.accept = pending.accept.join(",");
   }
+  input.multiple = pending.multiple === true;
   let settled = false;
   const finishFileSelection = status => {
     if (settled || pendingFileRequest === null || pendingFileRequest.id !== requestId) {
@@ -287,23 +277,36 @@ const startFileInput = pending => {
     hideFilePicker();
   };
   input.addEventListener("change", () => {
-    const file = input.files?.[0];
-    if (!file) {
+    const files = pending.multiple
+      ? Array.from(input.files || [])
+      : Array.from(input.files || []).slice(0, 1);
+    if (files.length === 0) {
       finishFileSelection("cancelled");
       return;
     }
-    const rejected = selectedFilePolicyStatus(
-      file.name || "",
-      file.size,
-      pending.accept,
-      pending.maxBytes,
-    );
+    let rejected = null;
+    for (const file of files) {
+      if (!fileNameMatchesAccept(file.name || "", pending.accept)) {
+        rejected = "disallowed_type";
+        break;
+      }
+    }
+    if (rejected === null) {
+      for (const file of files) {
+        if (file.size > pending.maxBytes) {
+          rejected = "too_large";
+          break;
+        }
+      }
+    }
     if (rejected !== null) {
       finishFileSelection(rejected);
       return;
     }
     const body = new FormData();
-    body.append("file", file, file.name);
+    for (const file of files) {
+      body.append("file", file, file.name);
+    }
     fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`, {
       method: "POST",
       body,
@@ -347,16 +350,19 @@ const openFileSelector = options => {
     id: requestId,
     accept,
     maxBytes: Number.isFinite(maxBytes) ? maxBytes : 0,
+    multiple: options.multiple === true,
   };
   showPromptDialog({
-    title: "The app requested a file",
+    title: pendingFileRequest.multiple
+      ? "The app requested files"
+      : "The app requested a file",
     details: [
       {
         label: "Accepted types",
         items: accept.length > 0 ? accept : ["Any"],
       },
       {
-        label: "Max size allowed",
+        label: "Max size per file",
         items: [formatByteBudget(pendingFileRequest.maxBytes)],
       },
     ],
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index e8121ac96..27cada9d0 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -29,10 +29,17 @@
 from torch.nn import functional as F
 
 from flashdreams.runtime_v2.cuda_utils import resolve_cuda_device
+from flashdreams.runtime_v2.selected_file import (
+    MAX_SELECTED_FILE_BATCH_BYTES,
+    SelectedFile,
+    SelectedFilesStatus,
+    clamp_selected_file_max_bytes,
+    normalize_selected_file_accept,
+    selected_files_policy_status,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    MAX_SELECTED_FILE_BYTES,
     CloseUserInputEvent,
     FocusUserInputEvent,
     GamepadUserInputEvent,
@@ -42,15 +49,10 @@
     MouseUserInputEvent,
     QueryStringUserInputEvent,
     ResetUserInputEvent,
-    SelectedFile,
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     UserInputEvent,
     XRControllerUserInputEvent,
-    clamp_selected_file_max_bytes,
-    normalize_selected_file_accept,
-    selected_file_policy_status,
 )
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
 
@@ -312,6 +314,9 @@ class _PendingFileSelection:
     max_bytes: int
     """Maximum file bytes, already clamped to the window ceiling."""
 
+    multiple: bool
+    """Whether this request may include more than one file."""
+
     generation: int
     """Gate generation that armed this request; a later generation drops it."""
 
@@ -470,6 +475,7 @@ def request_selected_files(
         *,
         accept: Sequence[str] = (),
         max_bytes: int | None = None,
+        multiple: bool = False,
         generation: int,
     ) -> None:
         """Ask the connected browser to open a file selector.
@@ -479,6 +485,7 @@ def request_selected_files(
             initial_path: Ignored; the browser picker cannot use a host path.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
+            multiple: Whether the selector may return more than one file.
             generation: Gate generation that admitted this request.
         """
         del initial_path
@@ -491,6 +498,7 @@ def request_selected_files(
             "id": request_id,
             "accept": list(suffixes),
             "max_bytes": budget,
+            "multiple": multiple,
         }
         loop = self._loop
         if loop is None:
@@ -504,14 +512,22 @@ def _arm_file_selector(self, payload: dict[str, Any], generation: int) -> None:
             raise TypeError("file selector id must be a string.")
         accept = payload["accept"]
         max_bytes = payload["max_bytes"]
-        if not isinstance(accept, list) or not isinstance(max_bytes, int):
-            raise TypeError("file selector payload must include accept and max_bytes.")
+        multiple = payload["multiple"]
+        if (
+            not isinstance(accept, list)
+            or not isinstance(max_bytes, int)
+            or not isinstance(multiple, bool)
+        ):
+            raise TypeError(
+                "file selector payload must include accept, max_bytes, and multiple."
+            )
         with self._file_selector_lock:
             if not self._file_selection_is_current(request_id, generation):
                 return
             self._pending_file_requests[request_id] = _PendingFileSelection(
                 accept=tuple(accept),
                 max_bytes=max_bytes,
+                multiple=multiple,
                 generation=generation,
             )
             channel = self._control_channel
@@ -894,7 +910,9 @@ def _run_server(self) -> None:
     async def _start_server(self) -> None:
         """Create and bind the standalone aiohttp application."""
         self._offer_lock = asyncio.Lock()
-        app = web.Application(client_max_size=MAX_SELECTED_FILE_BYTES + 1024 * 1024)
+        app = web.Application(
+            client_max_size=MAX_SELECTED_FILE_BATCH_BYTES + 1024 * 1024
+        )
         app.router.add_get("/", self._serve_browser)
         app.router.add_get("/app.js", self._serve_browser_script)
         app.router.add_get("/healthz", self._health)
@@ -974,19 +992,38 @@ def emit(
             emitted = True
 
         try:
+            max_body = (
+                MAX_SELECTED_FILE_BATCH_BYTES if policy.multiple else policy.max_bytes
+            ) + 1024 * 1024
+            content_length = request.content_length
+            if content_length is not None and content_length > max_body:
+                emit(SelectedFilesStatus.TOO_LARGE)
+                raise web.HTTPRequestEntityTooLarge(
+                    max_size=max_body,
+                    actual_size=content_length,
+                )
             try:
                 post = await request.post()
             except web.HTTPRequestEntityTooLarge:
                 emit(SelectedFilesStatus.TOO_LARGE)
                 raise
-            upload = post.get("file")
-            if not isinstance(upload, FileField):
+            uploads = [
+                upload
+                for upload in post.getall("file", [])
+                if isinstance(upload, FileField)
+            ]
+            if not policy.multiple:
+                uploads = uploads[:1]
+            if not uploads:
                 emit(SelectedFilesStatus.UNAVAILABLE)
                 raise web.HTTPBadRequest(reason="File upload requires a file.")
-            data = upload.file.read()
-            name = upload.filename or "upload"
-            rejected = selected_file_policy_status(
-                name, len(data), accept=policy.accept, max_bytes=policy.max_bytes
+            chosen: list[tuple[str, bytes]] = []
+            for upload in uploads:
+                chosen.append((upload.filename or "upload", upload.file.read()))
+            rejected = selected_files_policy_status(
+                [(name, len(data)) for name, data in chosen],
+                accept=policy.accept,
+                max_bytes=policy.max_bytes,
             )
             if rejected is SelectedFilesStatus.DISALLOWED_TYPE:
                 emit(rejected)
@@ -995,11 +1032,13 @@ def emit(
                 emit(rejected)
                 raise web.HTTPRequestEntityTooLarge(
                     max_size=policy.max_bytes,
-                    actual_size=len(data),
+                    actual_size=max(len(data) for _name, data in chosen),
                 )
             emit(
                 SelectedFilesStatus.OK,
-                files=(SelectedFile(name=name, data=data),),
+                files=tuple(
+                    SelectedFile(name=name, data=data) for name, data in chosen
+                ),
             )
             return web.Response(status=204)
         finally:
@@ -1382,7 +1421,7 @@ def _emit_selected_files(
                 request_id=request_id,
                 status=status,
                 files=files,
-                generation=generation,
+                _generation=generation,
             )
         )
 
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index ff6f7013a..35f9ccfbb 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -403,12 +403,7 @@ def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> No
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
     for selection in request.file_selections:
-        window.request_selected_files(
-            selection.request_id,
-            selection.initial_path,
-            accept=selection.accept,
-            max_bytes=selection.max_bytes,
-        )
+        window.request_selected_files(selection)
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 8e786a487..2dac1b55a 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -3,80 +3,12 @@
 
 """Concrete user input events for supported input modalities."""
 
-from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
 from typing import Literal
 
 from flashdreams.api_v2.user_input_event import UserInputEvent
-
-MAX_SELECTED_FILE_BYTES = 32 * 1024 * 1024
-"""Hard ceiling for one selected file. Windows clamp requested budgets to this."""
-
-
-def clamp_selected_file_max_bytes(max_bytes: int | None) -> int:
-    """Return a file-size budget that cannot exceed ``MAX_SELECTED_FILE_BYTES``.
-
-    Args:
-        max_bytes: Requested budget in bytes, or ``None`` for the ceiling.
-
-    Returns:
-        The requested budget when it is below the ceiling, otherwise the ceiling.
-
-    Raises:
-        TypeError: ``max_bytes`` is not ``None`` or an integer.
-        ValueError: ``max_bytes`` is not positive.
-    """
-    if max_bytes is None:
-        return MAX_SELECTED_FILE_BYTES
-    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int):
-        raise TypeError("max_bytes must be an integer.")
-    if max_bytes <= 0:
-        raise ValueError("max_bytes must be > 0.")
-    return min(max_bytes, MAX_SELECTED_FILE_BYTES)
-
-
-def normalize_selected_file_accept(accept: Sequence[str] = ()) -> tuple[str, ...]:
-    """Return accepted filename suffixes such as ``.png``.
-
-    Args:
-        accept: Suffixes the client may choose. Empty means any type.
-
-    Returns:
-        The suffixes as a tuple, unchanged except for the sequence type.
-
-    Raises:
-        TypeError: ``accept`` is not a sequence of strings.
-        ValueError: A suffix is missing the leading ``.`` or contains a path.
-    """
-    if isinstance(accept, str) or not isinstance(accept, Sequence):
-        raise TypeError("accept must be a sequence of suffixes.")
-    suffixes: list[str] = []
-    for suffix in accept:
-        if not isinstance(suffix, str):
-            raise TypeError("accept suffixes must be strings.")
-        if (
-            not suffix.startswith(".")
-            or suffix == "."
-            or "/" in suffix
-            or "\\" in suffix
-        ):
-            raise ValueError(
-                "accept suffixes must look like ``.png`` and cannot contain a path."
-            )
-        suffixes.append(suffix)
-    return tuple(suffixes)
-
-
-def selected_file_suffix_allowed(name: str, accept: tuple[str, ...]) -> bool:
-    """Return whether ``name`` matches ``accept``.
-
-    Empty ``accept`` allows any name. Comparison is case-insensitive.
-    """
-    if not accept:
-        return True
-    lower = name.lower()
-    return any(lower.endswith(suffix.lower()) for suffix in accept)
+from flashdreams.runtime_v2.selected_file import SelectedFile, SelectedFilesStatus
 
 
 class KeyboardInputState(Enum):
@@ -299,66 +231,6 @@ def get_type_name(cls) -> str:
     """Optional controller quaternion in client XR space."""
 
 
-class SelectedFilesStatus(Enum):
-    """Outcome of one client file-selector request."""
-
-    OK = "ok"
-    """The client chose a file that passed type and size checks."""
-
-    CANCELLED = "cancelled"
-    """The user dismissed the selector."""
-
-    TOO_LARGE = "too_large"
-    """The chosen file exceeded ``max_bytes``."""
-
-    DISALLOWED_TYPE = "disallowed_type"
-    """The chosen file did not match ``accept``. Checked before size."""
-
-    UNAVAILABLE = "unavailable"
-    """The picker could not complete: headless output, a gone client, a failed chooser, a missing upload, or an unreadable file."""
-
-
-def selected_file_policy_status(
-    name: str,
-    size: int | None,
-    *,
-    accept: tuple[str, ...] = (),
-    max_bytes: int,
-) -> SelectedFilesStatus | None:
-    """Return why a chosen file is rejected, or ``None`` if it is allowed.
-
-    Windows call this so every client uses the same order: type before size.
-    A too-large disallowed file is ``DISALLOWED_TYPE``. Applications only read
-    :class:`SelectedFilesUserInputEvent` ``status``. Pass ``size=None`` to
-    check only the name.
-
-    Args:
-        name: File name to match against ``accept``.
-        size: File size in bytes, or ``None`` to skip the size check.
-        accept: Filename suffixes such as ``.png``. Empty allows any type.
-        max_bytes: Maximum allowed size in bytes.
-
-    Returns:
-        ``DISALLOWED_TYPE``, ``TOO_LARGE``, or ``None`` when the file passes.
-    """
-    if not selected_file_suffix_allowed(name, accept):
-        return SelectedFilesStatus.DISALLOWED_TYPE
-    if size is not None and size > max_bytes:
-        return SelectedFilesStatus.TOO_LARGE
-    return None
-
-
-@dataclass(frozen=True, slots=True)
-class SelectedFile:
-    """One file chosen by a client file selector."""
-
-    name: str
-    """File name shown to the application."""
-
-    data: bytes
-    """File contents."""
-
-
 @dataclass(frozen=True, slots=True, eq=False)
 class SelectedFilesUserInputEvent(UserInputEvent):
     """Files chosen for one :meth:`IClientWindow.request_selected_files` call.
@@ -373,7 +245,7 @@ def get_type_name(cls) -> str:
         return "selected_files"
 
     request_id: str
-    """Identifier supplied with the matching file-selection request."""
+    """Stable id for which button this result is for. Same string the UI passed when it asked."""
 
     status: SelectedFilesStatus
     """Why this request completed. ``OK`` is the only value with files."""
@@ -381,7 +253,7 @@ def get_type_name(cls) -> str:
     files: tuple[SelectedFile, ...] = ()
     """Chosen files. Empty unless ``status`` is ``OK``."""
 
-    generation: int = 0
+    _generation: int = 0
     """Window generation that admitted this request. Applications ignore it."""
 
     def __post_init__(self) -> None:
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index b5992f4c5..cddbd0def 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -5,7 +5,6 @@
 
 import threading
 from collections import deque
-from collections.abc import Sequence
 from dataclasses import replace
 
 from numpy import uint64
@@ -15,14 +14,16 @@
     FileSelectionGate,
     QueuedFileSelection,
 )
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.serving.webrtc_server import WebRTCServer
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     UserInputEvent,
-    normalize_selected_file_accept,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
@@ -83,7 +84,7 @@ def handle_input(event: UserInputEvent) -> None:
             with self._input_lock:
                 if isinstance(event, SelectedFilesUserInputEvent):
                     claimed, nxt = self._file_gate.complete(
-                        event.request_id, event.generation
+                        event.request_id, event._generation
                     )
                     if not claimed:
                         return
@@ -125,35 +126,9 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         self.server.request_new_window_size(new_window_size)
 
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-    ) -> None:
-        """Ask the connected browser to open a file selector.
-
-        A second distinct ``request_id`` waits until the active selector
-        completes so the viewer shows one dialog at a time. A dropped peer
-        completes leftovers and in-flight picks as unavailable.
-
-        Args:
-            request_id: Stable selector-slot id from the UI control.
-            initial_path: Ignored by the browser picker; kept so the window
-                signature matches :meth:`IClientWindow.request_selected_files`.
-            accept: Filename suffixes such as ``.png``. Empty allows any type.
-            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
-        """
-        started = self._file_gate.submit(
-            QueuedFileSelection(
-                request_id=request_id,
-                initial_path=initial_path,
-                accept=normalize_selected_file_accept(accept),
-                max_bytes=max_bytes,
-            )
-        )
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        """Ask the connected browser to open a file selector."""
+        started = self._file_gate.submit(QueuedFileSelection.from_request(request))
         if started is not None:
             self._start_file_selection(started)
 
@@ -170,7 +145,7 @@ def _invalidate_file_selections(self, deliver_unavailable: bool) -> None:
                         timestamp=timestamp,
                         request_id=item.request_id,
                         status=SelectedFilesStatus.UNAVAILABLE,
-                        generation=item.generation,
+                        _generation=item.generation,
                     )
                 )
 
@@ -181,6 +156,7 @@ def _start_file_selection(self, pending: QueuedFileSelection) -> None:
             initial_path=pending.initial_path,
             accept=pending.accept,
             max_bytes=pending.max_bytes,
+            multiple=pending.multiple,
             generation=pending.generation,
         )
 
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index f2d92f67a..6a0655e0e 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -21,6 +21,10 @@
 from flashdreams.runtime_v2.native_window_client_window import (
     NativeWindowClientWindow,
 )
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
@@ -29,7 +33,6 @@
     KeyboardInputState,
     KeyboardUserInputEvent,
     MouseUserInputEvent,
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -41,6 +44,23 @@
 pytestmark = pytest.mark.ci_cpu
 
 
+def _file_request(
+    request_id: str,
+    initial_path: str,
+    *,
+    accept: tuple[str, ...] = (),
+    max_bytes: int | None = None,
+    multiple: bool = False,
+) -> FileSelectionRequest:
+    return FileSelectionRequest(
+        request_id=request_id,
+        initial_path=initial_path,
+        accept=accept,
+        max_bytes=max_bytes,
+        multiple=multiple,
+    )
+
+
 def _wait_for_input_events(window: NativeWindowClientWindow) -> list[object]:
     for _ in range(100):
         events = window.get_user_input_events().get_events()
@@ -635,14 +655,14 @@ def test_native_window_reports_a_selected_file(
     monkeypatch.setattr(
         native_window_module,
         "_ask_open_filename",
-        lambda *, initial_dir, accept=(): str(chosen),
+        lambda *, initial_dir, accept=(), multiple=False: (str(chosen),),
     )
     presenter = _Presenter()
     window = NativeWindowClientWindow(
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     events = _wait_for_input_events(window)
     window.close()
 
@@ -661,14 +681,14 @@ def test_native_window_reports_cancelled_file_selection(
     monkeypatch.setattr(
         native_window_module,
         "_ask_open_filename",
-        lambda *, initial_dir, accept=(): "",
+        lambda *, initial_dir, accept=(), multiple=False: (),
     )
     presenter = _Presenter()
     window = NativeWindowClientWindow(
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     events = _wait_for_input_events(window)
     window.close()
 
@@ -683,8 +703,13 @@ def test_native_window_reports_cancelled_file_selection(
 def test_native_window_reports_unavailable_when_picker_raises(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    def fail_picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-        del initial_dir, accept
+    def fail_picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple
         raise RuntimeError("Native file picker needs a desktop chooser.")
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", fail_picker)
@@ -693,7 +718,7 @@ def fail_picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     events = _wait_for_input_events(window)
     window.close()
 
@@ -712,13 +737,18 @@ def test_native_window_serves_one_file_selection_at_a_time(
     first_released = threading.Event()
     calls: list[tuple[str, ...]] = []
 
-    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-        del initial_dir
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+    ) -> tuple[str, ...]:
+        del initial_dir, multiple
         calls.append(accept)
         if len(calls) == 1:
             first_entered.set()
             assert first_released.wait(timeout=2.0)
-        return ""
+        return ()
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
@@ -726,9 +756,13 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path), accept=(".bin",))
+    window.request_selected_files(
+        _file_request("open-1", str(tmp_path), accept=(".bin",))
+    )
     assert first_entered.wait(timeout=2.0)
-    window.request_selected_files("open-2", str(tmp_path), accept=(".raw",))
+    window.request_selected_files(
+        _file_request("open-2", str(tmp_path), accept=(".raw",))
+    )
     assert calls == [(".bin",)]
     first_released.set()
     events = []
@@ -754,13 +788,18 @@ def test_native_window_ignores_duplicate_in_flight_file_selection_id(
     entered = threading.Event()
     calls: list[int] = []
 
-    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-        del initial_dir, accept
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple
         calls.append(1)
         entered.set()
         if len(calls) == 1:
             assert released.wait(timeout=2.0)
-        return ""
+        return ()
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
@@ -768,9 +807,9 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     assert entered.wait(timeout=2.0)
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     time.sleep(0.05)
     assert calls == [1]
     released.set()
@@ -792,11 +831,16 @@ def test_native_window_close_completes_leftover_file_selections(
     late = tmp_path / "late.bin"
     late.write_bytes(b"late")
 
-    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-        del initial_dir, accept
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple
         entered.set()
         assert released.wait(timeout=2.0)
-        return str(late)
+        return (str(late),)
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
@@ -804,8 +848,8 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
-    window.request_selected_files("open-2", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    window.request_selected_files(_file_request("open-2", str(tmp_path)))
     assert entered.wait(timeout=2.0)
     presenter.pending_events.put(("close", None))
     events = window.get_user_input_events().get_events()
@@ -833,12 +877,17 @@ def test_native_window_replacement_open_drops_leftover_file_selections(
     released = threading.Event()
     calls: list[int] = []
 
-    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-        del initial_dir, accept
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple
         calls.append(1)
         entered.set()
         assert released.wait(timeout=2.0)
-        return str(tmp_path / "late.bin")
+        return (str(tmp_path / "late.bin"),)
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
@@ -846,8 +895,8 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
-    window.request_selected_files("open-2", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    window.request_selected_files(_file_request("open-2", str(tmp_path)))
     assert entered.wait(timeout=2.0)
     window.open(_session_desc())
     events = window.get_user_input_events().get_events()
@@ -872,16 +921,21 @@ def test_native_window_stale_picker_does_not_complete_reused_request_id(
     zombie.write_bytes(b"old")
     calls: list[int] = []
 
-    def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
-        del initial_dir, accept
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple
         calls.append(1)
         if len(calls) == 1:
             first_entered.set()
             assert first_released.wait(timeout=2.0)
-            return str(zombie)
+            return (str(zombie),)
         second_entered.set()
         assert second_released.wait(timeout=2.0)
-        return ""
+        return ()
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
@@ -889,11 +943,11 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     assert first_entered.wait(timeout=2.0)
     window.close()
     window.open(_session_desc())
-    window.request_selected_files("open-1", str(tmp_path))
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
     assert second_entered.wait(timeout=2.0)
     first_released.set()
     time.sleep(0.05)
@@ -910,26 +964,28 @@ def picker(*, initial_dir: str, accept: tuple[str, ...] = ()) -> str:
     assert event.files == ()
 
 
-def test_selected_file_from_path_skips_unreadable_and_oversize(
+def test_selected_files_from_paths_skips_unreadable_and_oversize(
     tmp_path: Path,
 ) -> None:
     missing = tmp_path / "gone.png"
-    chosen, status = native_window_module._selected_file_from_path(missing)
-    assert chosen is None
+    files, status = native_window_module._selected_files_from_paths((str(missing),))
+    assert files == ()
     assert status is SelectedFilesStatus.UNAVAILABLE
 
     too_big = tmp_path / "big.bin"
     too_big.write_bytes(b"abcd")
-    chosen, status = native_window_module._selected_file_from_path(too_big, max_bytes=3)
-    assert chosen is None
+    files, status = native_window_module._selected_files_from_paths(
+        (str(too_big),), max_bytes=3
+    )
+    assert files == ()
     assert status is SelectedFilesStatus.TOO_LARGE
 
     wrong_type = tmp_path / "notes.txt"
     wrong_type.write_bytes(b"hi")
-    chosen, status = native_window_module._selected_file_from_path(
-        wrong_type, accept=(".png",)
+    files, status = native_window_module._selected_files_from_paths(
+        (str(wrong_type),), accept=(".png",)
     )
-    assert chosen is None
+    assert files == ()
     assert status is SelectedFilesStatus.DISALLOWED_TYPE
 
 
@@ -948,21 +1004,17 @@ def fake_run(argv: list[str], **kwargs: object) -> object:
         return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
 
     monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
-    assert (
-        native_window_module._ask_open_filename_linux(initial_dir="/tmp")
-        == "/tmp/seed.png"
+    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == (
+        "/tmp/seed.png",
     )
     assert calls[0][0] == "/usr/bin/zenity"
     assert "--file-selection" in calls[0]
     assert any(arg.startswith("--filename=/tmp/") for arg in calls[0])
     assert not any(arg.startswith("--file-filter=") for arg in calls[0])
-    assert (
-        native_window_module._ask_open_filename_linux(
-            initial_dir="/tmp",
-            accept=(".png", ".jpg"),
-        )
-        == "/tmp/seed.png"
-    )
+    assert native_window_module._ask_open_filename_linux(
+        initial_dir="/tmp",
+        accept=(".png", ".jpg"),
+    ) == ("/tmp/seed.png",)
     assert "--file-filter=Accepted | *.png *.jpg" in calls[1]
 
 
@@ -979,7 +1031,7 @@ def test_ask_open_filename_linux_cancel_is_empty(
         "run",
         lambda argv, **kwargs: SimpleNamespace(returncode=1, stdout=""),
     )
-    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == ""
+    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == ()
 
 
 def test_ask_open_filename_linux_error_raises(
@@ -1001,6 +1053,57 @@ def test_ask_open_filename_linux_error_raises(
         native_window_module._ask_open_filename_linux(initial_dir="/tmp")
 
 
+def test_ask_open_filename_linux_multiple_uses_newline_separator(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+    calls: list[list[str]] = []
+
+    def fake_run(argv: list[str], **kwargs: object) -> object:
+        calls.append(argv)
+        return SimpleNamespace(returncode=0, stdout="/tmp/a.bin\n/tmp/b.bin\n")
+
+    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    assert native_window_module._ask_open_filename_linux(
+        initial_dir="/tmp", multiple=True
+    ) == ("/tmp/a.bin", "/tmp/b.bin")
+    assert "--multiple" in calls[0]
+    assert "--separator=\n" in calls[0]
+
+
+def test_native_window_reports_multiple_selected_files(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    first = tmp_path / "a.bin"
+    second = tmp_path / "b.bin"
+    first.write_bytes(b"one")
+    second.write_bytes(b"two")
+    monkeypatch.setattr(
+        native_window_module,
+        "_ask_open_filename",
+        lambda *, initial_dir, accept=(), multiple=False: (str(first), str(second)),
+    )
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+    )
+    window.open(_session_desc())
+    window.request_selected_files(_file_request("open-1", str(tmp_path), multiple=True))
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.status is SelectedFilesStatus.OK
+    assert [chosen.name for chosen in event.files] == ["a.bin", "b.bin"]
+    assert [chosen.data for chosen in event.files] == [b"one", b"two"]
+
+
 def test_native_window_reports_standard_gamepad_events() -> None:
     presenter = _Presenter()
     clock_values = iter((1_000_000, 1_001_000, 1_002_000, 1_003_000))
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 4e77a4aad..f32579940 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -18,18 +18,21 @@
 from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
 from flashdreams.runtime_v2.null_client_window import NullClientWindow
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
-from flashdreams.runtime_v2.session_desc import SessionDesc
-from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import (
+from flashdreams.runtime_v2.selected_file import (
+    MAX_SELECTED_FILE_BATCH_BYTES,
     MAX_SELECTED_FILE_BYTES,
+    FileSelectionRequest,
     SelectedFile,
     SelectedFilesStatus,
-    SelectedFilesUserInputEvent,
     clamp_selected_file_max_bytes,
     normalize_selected_file_accept,
     selected_file_policy_status,
     selected_file_suffix_allowed,
+    selected_files_policy_status,
 )
+from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 pytestmark = pytest.mark.ci_cpu
@@ -91,6 +94,16 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     assert selection.initial_path == "/tmp"
     assert selection.accept == (".png", ".JPG")
     assert selection.max_bytes == MAX_SELECTED_FILE_BYTES * 2
+    assert selection.multiple is False
+
+
+def test_ui_loop_queues_multiple_file_selection() -> None:
+    loop = _ui_loop()
+    loop.request_selected_files("open-1", "/tmp", multiple=True)
+
+    requests = loop.flush_ui_loop_requests()
+    assert requests is not None
+    assert requests.file_selections[0].multiple is True
 
 
 def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
@@ -185,6 +198,38 @@ def test_selected_file_policy_helpers() -> None:
         selected_file_policy_status("seed.png", 2, accept=(".png",), max_bytes=3)
         is None
     )
+    assert (
+        selected_files_policy_status(
+            [("a.bin", 2), ("b.txt", 2)],
+            accept=(".bin",),
+            max_bytes=3,
+        )
+        is SelectedFilesStatus.DISALLOWED_TYPE
+    )
+    assert (
+        selected_files_policy_status(
+            [("a.bin", 2), ("b.bin", 99)],
+            accept=(".bin",),
+            max_bytes=3,
+        )
+        is SelectedFilesStatus.TOO_LARGE
+    )
+    assert (
+        selected_files_policy_status(
+            [("a.bin", MAX_SELECTED_FILE_BATCH_BYTES), ("b.bin", 1)],
+            accept=(".bin",),
+            max_bytes=MAX_SELECTED_FILE_BYTES,
+        )
+        is SelectedFilesStatus.TOO_LARGE
+    )
+    assert (
+        selected_files_policy_status(
+            [("a.bin", 2), ("b.bin", 2)],
+            accept=(".bin",),
+            max_bytes=3,
+        )
+        is None
+    )
 
 
 def test_ui_loop_rejects_invalid_accept() -> None:
@@ -193,6 +238,12 @@ def test_ui_loop_rejects_invalid_accept() -> None:
         loop.request_selected_files("open-1", accept=("png",))
 
 
+def test_ui_loop_rejects_invalid_multiple() -> None:
+    loop = _ui_loop()
+    with pytest.raises(TypeError, match="multiple must be a bool"):
+        loop.request_selected_files("open-1", multiple=1)  # type: ignore[arg-type]
+
+
 def test_selected_files_event_rejects_inconsistent_status() -> None:
     with pytest.raises(ValueError, match="must include files"):
         SelectedFilesUserInputEvent(
@@ -216,8 +267,12 @@ def test_headless_window_completes_queued_file_selections_as_unavailable(
     window = (
         Mp4ClientWindow(tmp_path / "clip.mp4") if kind == "mp4" else NullClientWindow()
     )
-    window.request_selected_files("open-1", "/tmp")
-    window.request_selected_files("open-2", "/var")
+    window.request_selected_files(
+        FileSelectionRequest(request_id="open-1", initial_path="/tmp")
+    )
+    window.request_selected_files(
+        FileSelectionRequest(request_id="open-2", initial_path="/var")
+    )
 
     events = window.get_user_input_events().get_events()
 
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index bb319a0ae..a1be419d5 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -7,7 +7,7 @@
 import queue
 import threading
 import time
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import replace
 from pathlib import Path
@@ -35,6 +35,7 @@
     PresentationManager,
     _PresentationClock,
 )
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -660,9 +661,7 @@ def __init__(
         self.session_desc: SessionDesc | None = None
         self.results: list[StepResult] = []
         self.cursor_requests: list[tuple[str, bool]] = []
-        self.file_selection_requests: list[
-            tuple[str, str | None, tuple[str, ...], int | None]
-        ] = []
+        self.file_selection_requests: list[FileSelectionRequest] = []
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Record one cursor visibility request."""
@@ -674,19 +673,10 @@ def request_lock_cursor_to_window(self, lock_cursor_to_window: bool) -> None:
         self._log.record("window.request_lock_cursor_to_window")
         self.cursor_requests.append(("lock", lock_cursor_to_window))
 
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-    ) -> None:
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Record one file-selector request."""
         self._log.record("window.request_selected_files")
-        self.file_selection_requests.append(
-            (request_id, initial_path, tuple(accept), max_bytes)
-        )
+        self.file_selection_requests.append(request)
 
     def get_user_input_events(self) -> UserInputEvents:
         self._log.record("window.get_user_input_events")
@@ -1401,7 +1391,14 @@ def init(self) -> None:
     window = RecordingClientWindow(log)
     run_session(RequestingSession(_session_desc(), log), window, steps=1)
 
-    assert window.file_selection_requests == [("open-1", "/tmp", (".png",), 1024)]
+    assert window.file_selection_requests == [
+        FileSelectionRequest(
+            request_id="open-1",
+            initial_path="/tmp",
+            accept=(".png",),
+            max_bytes=1024,
+        )
+    ]
     assert "window.request_selected_files" in log.calls
 
 
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index b9f50d417..dabf2981a 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -33,10 +33,14 @@
 
 from flashdreams.runtime_v2.serving import webrtc_server
 from flashdreams.runtime_v2.serving.webrtc_server import _VideoTrack
+from flashdreams.runtime_v2.selected_file import (
+    MAX_SELECTED_FILE_BYTES,
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    MAX_SELECTED_FILE_BYTES,
     FocusUserInputEvent,
     GamepadUserInputEvent,
     GameWheelUserInputEvent,
@@ -44,7 +48,6 @@
     KeyboardUserInputEvent,
     MouseUserInputEvent,
     QueryStringUserInputEvent,
-    SelectedFilesStatus,
     SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     XRControllerUserInputEvent,
@@ -53,6 +56,23 @@
 from flashdreams.runtime_v2.webrtc_client_window import WebRTCClientWindow
 
 
+def _file_request(
+    request_id: str,
+    initial_path: str = "/tmp",
+    *,
+    accept: tuple[str, ...] = (),
+    max_bytes: int | None = None,
+    multiple: bool = False,
+) -> FileSelectionRequest:
+    return FileSelectionRequest(
+        request_id=request_id,
+        initial_path=initial_path,
+        accept=accept,
+        max_bytes=max_bytes,
+        multiple=multiple,
+    )
+
+
 def _files_url(window: WebRTCClientWindow, request_id: str) -> str:
     return f"{window.server.url}api/files?request_id={request_id}"
 
@@ -83,6 +103,37 @@ async def _post_selected_file(
             return response.status
 
 
+@pytest.mark.asyncio
+async def test_file_upload_accepts_multiple_files() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(_file_request("open-1", multiple=True))
+        await _wait_file_armed(window, "open-1")
+        form = FormData()
+        form.add_field(
+            "file",
+            b"one",
+            filename="a.bin",
+            content_type="application/octet-stream",
+        )
+        form.add_field(
+            "file",
+            b"two",
+            filename="b.bin",
+            content_type="application/octet-stream",
+        )
+        async with ClientSession() as client:
+            async with client.post(_files_url(window, "open-1"), data=form) as response:
+                assert response.status == 204
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.OK
+        assert [chosen.name for chosen in event.files] == ["a.bin", "b.bin"]
+        assert [chosen.data for chosen in event.files] == [b"one", b"two"]
+    finally:
+        window.close()
+
+
 def _session_desc(
     presentation_mode: PresentationMode = PresentationMode.ON_DEMAND,
 ) -> SessionDesc:
@@ -179,9 +230,9 @@ async def test_browser_file_selections_are_served_one_at_a_time() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files("open-1", "/tmp")
-        window.request_selected_files("open-1", "/tmp")
-        window.request_selected_files("open-2", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
+        window.request_selected_files(_file_request("open-1"))
+        window.request_selected_files(_file_request("open-2"))
         await _wait_file_armed(window, "open-1")
         assert "open-2" not in window.server._pending_file_requests
         assert await _post_selected_file(window, "open-2", b"early", "early.txt") == 409
@@ -217,8 +268,8 @@ async def test_peer_loss_completes_queued_file_selections_as_unavailable() -> No
     replacement: RTCPeerConnection | None = None
     try:
         peer, _, _ = await _connect_browser(window)
-        window.request_selected_files("open-1", "/tmp")
-        window.request_selected_files("open-2", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
+        window.request_selected_files(_file_request("open-2"))
         await _wait_file_armed(window, "open-1")
         assert "open-2" not in window.server._pending_file_requests
         await peer.close()
@@ -261,7 +312,7 @@ async def test_in_flight_upload_is_dropped_after_peer_loss(
     peer: RTCPeerConnection | None = None
     try:
         peer, _, _ = await _connect_browser(window)
-        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         original_post = web.Request.post
         disconnected = False
@@ -312,7 +363,7 @@ def capture_arm(payload: dict[str, Any], generation: int) -> None:
             delayed.append((payload, generation))
 
         monkeypatch.setattr(window.server, "_arm_file_selector", capture_arm)
-        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
         for _ in range(100):
             if delayed:
                 break
@@ -388,10 +439,12 @@ def on_message(message: object) -> None:
                 messages.append(json.loads(message))
 
         window.request_selected_files(
-            "open-1",
-            "/home/secret",
-            accept=(".png", ".jpg"),
-            max_bytes=MAX_SELECTED_FILE_BYTES * 2,
+            _file_request(
+                "open-1",
+                "/home/secret",
+                accept=(".png", ".jpg"),
+                max_bytes=MAX_SELECTED_FILE_BYTES * 2,
+            )
         )
         for _ in range(100):
             if any(item.get("type") == "file_selector" for item in messages):
@@ -403,6 +456,7 @@ def on_message(message: object) -> None:
             "id": "open-1",
             "accept": [".png", ".jpg"],
             "max_bytes": MAX_SELECTED_FILE_BYTES,
+            "multiple": False,
         }
     finally:
         if peer is not None:
@@ -430,7 +484,7 @@ async def test_file_upload_without_file_is_unavailable() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files("open-1")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         form = FormData()
         form.add_field("not_file", "hello")
@@ -450,7 +504,7 @@ async def test_file_upload_rejects_oversize() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files("open-1", max_bytes=1)
+        window.request_selected_files(_file_request("open-1", max_bytes=1))
         await _wait_file_armed(window, "open-1")
         status = await _post_selected_file(window, "open-1", b"x" * 8192, "big.bin")
         assert status == 413
@@ -467,7 +521,9 @@ async def test_file_upload_prefers_disallowed_suffix_over_oversize() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files("open-1", accept=(".png",), max_bytes=1)
+        window.request_selected_files(
+            _file_request("open-1", accept=(".png",), max_bytes=1)
+        )
         await _wait_file_armed(window, "open-1")
         assert (
             await _post_selected_file(window, "open-1", b"x" * 8192, "hello.txt") == 204
@@ -487,7 +543,7 @@ async def test_browser_file_selector_result_reports_status() -> None:
     peer: RTCPeerConnection | None = None
     try:
         peer, channel, _ = await _connect_browser(window)
-        window.request_selected_files("open-1")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         channel.send(
             json.dumps(
@@ -513,11 +569,11 @@ async def test_session_handoff_clears_pending_file_selection() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         window.open(_session_desc())
         assert "open-1" not in window.server._pending_file_requests
-        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
     finally:
@@ -531,7 +587,7 @@ async def test_in_flight_upload_is_dropped_after_session_handoff(
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         original_post = web.Request.post
         handed_off = False
@@ -547,7 +603,7 @@ async def post_after_handoff(request: web.Request) -> Any:
         assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
         assert window.get_user_input_events().get_events() == []
 
-        window.request_selected_files("open-1", "/tmp")
+        window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
         assert await _post_selected_file(window, "open-1", b"next", "next.txt") == 204
         events = []
@@ -659,14 +715,16 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                     in browser_script
                 )
                 assert "input.accept" in browser_script
+                assert "input.multiple" in browser_script
                 assert "file.size" in browser_script
                 assert 'addEventListener("cancel"' in browser_script
-                assert "selectedFilePolicyStatus" in browser_script
+                assert "fileNameMatchesAccept" in browser_script
                 assert "showPromptDialog" in browser_script
                 assert "showModal" not in browser_script
                 assert "The app requested a file" in browser_script
+                assert "The app requested files" in browser_script
                 assert 'label: "Accepted types"' in browser_script
-                assert 'label: "Max size allowed"' in browser_script
+                assert 'label: "Max size per file"' in browser_script
                 assert "Choose file" not in browser_page
                 assert "response.ok" in browser_script
 
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index d7ec3161e..887b5ec0b 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -34,8 +34,9 @@ Run the file-picker application. Native Linux needs `zenity` or `kdialog`
 (the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
 confirmation dialog in the viewer (the picker must open from a browser click).
 The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Controls are
-**Open file (A)**, **Open file (B)**, and **Open A then B**. Failed picks
-show in red with the `SelectedFilesStatus` name and why.
+**Open file (A)**, **Open file (B)**, **Open A then B**, and **Open files**
+(more than one file). Failed picks show in red with the
+`SelectedFilesStatus` name and why.
 ```bash
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode native-window
 uv run --no-sync flashdreams-run-v2 imgui-ui-file-picker --mode webrtc \
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 5869c2724..c403064c9 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -17,11 +17,11 @@
 from flashdreams.runtime_v2.imgui_ui_loop import ImGuiUILoop
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import (
+from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BYTES,
     SelectedFilesStatus,
-    SelectedFilesUserInputEvent,
 )
+from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
 
@@ -68,6 +68,12 @@
 _OPEN_A_THEN_B_LABEL = "Open A then B"
 """ImGui label that requests A then B in the same UI tick."""
 
+_OPEN_FILES_REQUEST_ID = "open-files"
+"""Selector slot for Open files. Asks for more than one file."""
+
+_OPEN_FILES_LABEL = "Open files"
+"""ImGui label for a multi-file selector slot."""
+
 
 class BreathingBackgroundModelLoop(IModelLoop[tuple[SessionDesc, torch.device | str]]):
     """Generate a black-to-gray breathing background for the file-picker demo."""
@@ -124,11 +130,12 @@ def step_ui(
             if event.status is not SelectedFilesStatus.OK:
                 self.state.status = _FILE_SELECTION_STATUS_TEXT[event.status]
                 continue
-            chosen = event.files[0]
-            self.state.status = f"{chosen.name} ({len(chosen.data)} bytes)"
+            self.state.status = ", ".join(
+                f"{chosen.name} ({len(chosen.data)} bytes)" for chosen in event.files
+            )
 
         imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
-        imgui.set_next_window_size(imgui.ImVec2(520.0, 260.0), imgui.Cond_.once)
+        imgui.set_next_window_size(imgui.ImVec2(520.0, 300.0), imgui.Cond_.once)
         imgui.begin("File picker")
         try:
             if imgui.button(_OPEN_FILE_A_LABEL):
@@ -138,6 +145,8 @@ def step_ui(
             if imgui.button(_OPEN_A_THEN_B_LABEL):
                 self._request_demo_file(_OPEN_FILE_A_REQUEST_ID)
                 self._request_demo_file(_OPEN_FILE_B_REQUEST_ID)
+            if imgui.button(_OPEN_FILES_LABEL):
+                self._request_demo_file(_OPEN_FILES_REQUEST_ID, multiple=True)
             if self.state.status in _FILE_SELECTION_STATUS_TEXT.values():
                 imgui.push_style_color(
                     imgui.Col_.text,
@@ -153,12 +162,13 @@ def step_ui(
             imgui.end()
         return self.presented_model_frame()
 
-    def _request_demo_file(self, request_id: str) -> None:
+    def _request_demo_file(self, request_id: str, *, multiple: bool = False) -> None:
         """Ask for a ``.bin`` / ``.raw`` pick on one selector slot."""
         self.request_selected_files(
             request_id,
             accept=(".bin", ".raw"),
             max_bytes=MAX_SELECTED_FILE_BYTES,
+            multiple=multiple,
         )
 
     def reset(self) -> None:
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 42a35bbda..58c793424 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -17,6 +17,8 @@
     _OPEN_FILE_A_REQUEST_ID,
     _OPEN_FILE_B_LABEL,
     _OPEN_FILE_B_REQUEST_ID,
+    _OPEN_FILES_LABEL,
+    _OPEN_FILES_REQUEST_ID,
     FilePickerImGuiUILoop,
     FilePickerState,
 )
@@ -25,12 +27,12 @@
 
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
 from flashdreams.runtime_v2.session_desc import SessionDesc
-from flashdreams.runtime_v2.user_input_event import (
+from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BYTES,
     SelectedFile,
     SelectedFilesStatus,
-    SelectedFilesUserInputEvent,
 )
+from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 pytestmark = pytest.mark.ci_cpu
@@ -121,6 +123,23 @@ def test_open_file_button_requests_a_client_file(label: str, request_id: str) ->
     assert [item.request_id for item in requests.file_selections] == [request_id]
     assert requests.file_selections[0].accept == (".bin", ".raw")
     assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
+    assert requests.file_selections[0].multiple is False
+
+
+def test_open_files_button_requests_multiple_client_files() -> None:
+    _state, loop = _file_picker_loop()
+    imgui = _file_picker_imgui(pressed=_OPEN_FILES_LABEL)
+
+    loop.step_ui(imgui, 0, UserInputEvents([]))
+    requests = loop.flush_ui_loop_requests()
+
+    assert requests is not None
+    assert [item.request_id for item in requests.file_selections] == [
+        _OPEN_FILES_REQUEST_ID
+    ]
+    assert requests.file_selections[0].accept == (".bin", ".raw")
+    assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
+    assert requests.file_selections[0].multiple is True
 
 
 def test_open_a_then_b_queues_both_request_ids() -> None:
@@ -162,6 +181,34 @@ def test_selected_files_event_updates_file_picker_status() -> None:
     imgui.push_style_color.assert_not_called()
 
 
+def test_selected_files_event_lists_every_chosen_file() -> None:
+    state, loop = _file_picker_loop()
+    imgui = _file_picker_imgui()
+
+    loop.step_ui(
+        imgui,
+        0,
+        UserInputEvents(
+            [
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=_OPEN_FILES_REQUEST_ID,
+                    status=SelectedFilesStatus.OK,
+                    files=(
+                        SelectedFile(name="a.bin", data=b"aa"),
+                        SelectedFile(name="b.raw", data=b"bbb"),
+                    ),
+                )
+            ]
+        ),
+    )
+
+    assert state.status == "a.bin (2 bytes), b.raw (3 bytes)"
+    imgui.text.assert_called_with("a.bin (2 bytes), b.raw (3 bytes)")
+    imgui.text_wrapped.assert_not_called()
+    imgui.push_style_color.assert_not_called()
+
+
 def test_file_picker_shows_error_status_in_red() -> None:
     assert set(_FILE_SELECTION_STATUS_TEXT) == {
         status for status in SelectedFilesStatus if status is not SelectedFilesStatus.OK

From 0f3e25b873a2e8e3c5ba6a343c249717f5cb7087 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 5 Oct 2026 15:02:37 -0700
Subject: [PATCH 20/43] Check upload type before size and keep newlines in
 zenity filenames.

Streaming the WebRTC POST reports a disallowed suffix even when the body
is over the cap. Zenity multiple paths split on '//' because NUL cannot
be passed in argv.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 .../runtime_v2/native_window_client_window.py |  15 ++-
 .../runtime_v2/serving/webrtc_server.py       | 112 ++++++++++++----
 .../test_native_window_client_window.py       |  45 ++++++-
 flashdreams/test_v2/test_selected_files.py    |  23 +++-
 .../test_v2/test_webrtc_client_window.py      | 125 ++++++++++++------
 5 files changed, 244 insertions(+), 76 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index e76288cfd..4ccacbd88 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -105,7 +105,9 @@ def _ask_open_filename_linux(
             "--title=Select a file",
         ]
         if multiple:
-            argv.extend(("--multiple", "--separator=\n"))
+            # '/' cannot appear in a filename, so '//' joins two absolute
+            # paths. NUL cannot be passed in argv.
+            argv.extend(("--multiple", "--separator=/"))
         if patterns:
             argv.append(f"--file-filter=Accepted | {patterns}")
         return _parse_chooser_stdout(
@@ -162,7 +164,16 @@ def _parse_chooser_stdout(
         return (output,)
     if quoted:
         return tuple(shlex.split(output))
-    return tuple(line for line in output.splitlines() if line)
+    return _split_zenity_absolute_paths(output)
+
+
+def _split_zenity_absolute_paths(output: str) -> tuple[str, ...]:
+    """Split zenity ``--separator=/`` stdout into absolute paths.
+
+    A newline inside a filename stays in that path.
+    """
+    head, *tail = output.split("//")
+    return (head, *(f"/{part}" for part in tail if part))
 
 
 def _ask_open_filename_tkinter(
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 27cada9d0..b113f1056 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -21,7 +21,7 @@
 import numpy as np
 import torch
 from aiohttp import web
-from aiohttp.web_request import FileField
+from aiohttp.multipart import BodyPartReader, MultipartReader
 from aiortc import MediaStreamTrack, RTCPeerConnection, RTCSessionDescription
 from aiortc.mediastreams import MediaStreamError
 from av import VideoFrame
@@ -35,6 +35,7 @@
     SelectedFilesStatus,
     clamp_selected_file_max_bytes,
     normalize_selected_file_accept,
+    selected_file_suffix_allowed,
     selected_files_policy_status,
 )
 from flashdreams.runtime_v2.session_desc import SessionDesc
@@ -992,48 +993,58 @@ def emit(
             emitted = True
 
         try:
-            max_body = (
-                MAX_SELECTED_FILE_BATCH_BYTES if policy.multiple else policy.max_bytes
-            ) + 1024 * 1024
-            content_length = request.content_length
-            if content_length is not None and content_length > max_body:
-                emit(SelectedFilesStatus.TOO_LARGE)
-                raise web.HTTPRequestEntityTooLarge(
-                    max_size=max_body,
-                    actual_size=content_length,
-                )
+            if not request.content_type.startswith("multipart/"):
+                emit(SelectedFilesStatus.UNAVAILABLE)
+                raise web.HTTPBadRequest(reason="File upload requires a file.")
             try:
-                post = await request.post()
+                reader = await request.multipart()
             except web.HTTPRequestEntityTooLarge:
                 emit(SelectedFilesStatus.TOO_LARGE)
                 raise
-            uploads = [
-                upload
-                for upload in post.getall("file", [])
-                if isinstance(upload, FileField)
-            ]
-            if not policy.multiple:
-                uploads = uploads[:1]
-            if not uploads:
+            chosen: list[tuple[str, bytes]] = []
+            while True:
+                part = await reader.next()
+                if part is None:
+                    break
+                if not isinstance(part, BodyPartReader):
+                    continue
+                if part.name != "file":
+                    await part.release()
+                    continue
+                if not policy.multiple and chosen:
+                    await part.release()
+                    continue
+                name = part.filename or "upload"
+                if not selected_file_suffix_allowed(name, policy.accept):
+                    emit(SelectedFilesStatus.DISALLOWED_TYPE)
+                    await _drain_multipart_reader(reader, part)
+                    return web.Response(status=204)
+                data = await _read_upload_part_bounded(part, max_bytes=policy.max_bytes)
+                if data is None:
+                    emit(SelectedFilesStatus.TOO_LARGE)
+                    await _drain_multipart_reader(reader)
+                    raise web.HTTPRequestEntityTooLarge(
+                        max_size=policy.max_bytes,
+                        actual_size=policy.max_bytes + 1,
+                    )
+                chosen.append((name, data))
+            if not chosen:
                 emit(SelectedFilesStatus.UNAVAILABLE)
                 raise web.HTTPBadRequest(reason="File upload requires a file.")
-            chosen: list[tuple[str, bytes]] = []
-            for upload in uploads:
-                chosen.append((upload.filename or "upload", upload.file.read()))
             rejected = selected_files_policy_status(
                 [(name, len(data)) for name, data in chosen],
                 accept=policy.accept,
                 max_bytes=policy.max_bytes,
             )
-            if rejected is SelectedFilesStatus.DISALLOWED_TYPE:
-                emit(rejected)
-                return web.Response(status=204)
             if rejected is SelectedFilesStatus.TOO_LARGE:
                 emit(rejected)
                 raise web.HTTPRequestEntityTooLarge(
                     max_size=policy.max_bytes,
                     actual_size=max(len(data) for _name, data in chosen),
                 )
+            if rejected is not None:
+                emit(rejected)
+                return web.Response(status=204)
             emit(
                 SelectedFilesStatus.OK,
                 files=tuple(
@@ -1041,6 +1052,10 @@ def emit(
                 ),
             )
             return web.Response(status=204)
+        except web.HTTPRequestEntityTooLarge:
+            if not emitted:
+                emit(SelectedFilesStatus.TOO_LARGE)
+            raise
         finally:
             if not emitted:
                 try:
@@ -1520,6 +1535,51 @@ async def _shutdown(self) -> None:
             raise primary
 
 
+_UPLOAD_READ_CHUNK_BYTES = 64 * 1024
+"""Bytes read per multipart chunk while enforcing ``max_bytes``."""
+
+
+async def _read_upload_part_bounded(
+    part: BodyPartReader, *, max_bytes: int
+) -> bytes | None:
+    """Return the part body, or ``None`` when it exceeds ``max_bytes``.
+
+    Args:
+        part: Multipart file part whose headers have already been read.
+        max_bytes: Maximum allowed size of this file in bytes.
+
+    Returns:
+        The assembled bytes, or ``None`` when the part is larger than
+        ``max_bytes``.
+    """
+    chunks: list[bytes] = []
+    total = 0
+    while True:
+        chunk = await part.read_chunk(_UPLOAD_READ_CHUNK_BYTES)
+        if not chunk:
+            break
+        total += len(chunk)
+        if total > max_bytes:
+            await part.release()
+            return None
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
+async def _drain_multipart_reader(
+    reader: MultipartReader, part: BodyPartReader | None = None
+) -> None:
+    """Consume leftover multipart parts so the request can finish."""
+    if part is not None:
+        await part.release()
+    while True:
+        leftover = await reader.next()
+        if leftover is None:
+            break
+        if isinstance(leftover, BodyPartReader):
+            await leftover.release()
+
+
 def _same_stream_format(first: SessionDesc, second: SessionDesc) -> bool:
     """Return whether two sessions can share one negotiated video track."""
     return (
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 6a0655e0e..c3749e63a 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -988,6 +988,14 @@ def test_selected_files_from_paths_skips_unreadable_and_oversize(
     assert files == ()
     assert status is SelectedFilesStatus.DISALLOWED_TYPE
 
+    too_big_wrong_type = tmp_path / "huge.txt"
+    too_big_wrong_type.write_bytes(b"abcd")
+    files, status = native_window_module._selected_files_from_paths(
+        (str(too_big_wrong_type),), accept=(".png",), max_bytes=1
+    )
+    assert files == ()
+    assert status is SelectedFilesStatus.DISALLOWED_TYPE
+
 
 def test_ask_open_filename_linux_uses_zenity(
     monkeypatch: pytest.MonkeyPatch,
@@ -1053,7 +1061,7 @@ def test_ask_open_filename_linux_error_raises(
         native_window_module._ask_open_filename_linux(initial_dir="/tmp")
 
 
-def test_ask_open_filename_linux_multiple_uses_newline_separator(
+def test_ask_open_filename_linux_multiple_uses_slash_separator(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setattr(
@@ -1065,14 +1073,45 @@ def test_ask_open_filename_linux_multiple_uses_newline_separator(
 
     def fake_run(argv: list[str], **kwargs: object) -> object:
         calls.append(argv)
-        return SimpleNamespace(returncode=0, stdout="/tmp/a.bin\n/tmp/b.bin\n")
+        return SimpleNamespace(returncode=0, stdout="/tmp/foo\nbar.bin//tmp/baz.bin\n")
+
+    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    assert native_window_module._ask_open_filename_linux(
+        initial_dir="/tmp", multiple=True
+    ) == ("/tmp/foo\nbar.bin", "/tmp/baz.bin")
+    assert "--multiple" in calls[0]
+    assert "--separator=/" in calls[0]
+
+
+def test_ask_open_filename_linux_falls_back_to_kdialog(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/kdialog" if name == "kdialog" else None,
+    )
+    calls: list[list[str]] = []
+
+    def fake_run(argv: list[str], **kwargs: object) -> object:
+        calls.append(argv)
+        return SimpleNamespace(returncode=0, stdout="'/tmp/a.bin' '/tmp/b.bin'\n")
 
     monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
     assert native_window_module._ask_open_filename_linux(
         initial_dir="/tmp", multiple=True
     ) == ("/tmp/a.bin", "/tmp/b.bin")
+    assert calls[0][0] == "/usr/bin/kdialog"
+    assert "--getopenfilename" in calls[0]
     assert "--multiple" in calls[0]
-    assert "--separator=\n" in calls[0]
+
+
+def test_ask_open_filename_linux_requires_a_desktop_chooser(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(native_window_module.shutil, "which", lambda name: None)
+    with pytest.raises(RuntimeError, match="zenity or kdialog"):
+        native_window_module._ask_open_filename_linux(initial_dir="/tmp")
 
 
 def test_native_window_reports_multiple_selected_files(
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index f32579940..b1facf7db 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -83,6 +83,7 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
         "/tmp",
         accept=(".png", ".JPG"),
         max_bytes=MAX_SELECTED_FILE_BYTES * 2,
+        multiple=True,
     )
     loop.request_selected_files("open-1", "/var")
 
@@ -94,16 +95,16 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     assert selection.initial_path == "/tmp"
     assert selection.accept == (".png", ".JPG")
     assert selection.max_bytes == MAX_SELECTED_FILE_BYTES * 2
-    assert selection.multiple is False
+    assert selection.multiple is True
 
 
-def test_ui_loop_queues_multiple_file_selection() -> None:
+def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
     loop = _ui_loop()
-    loop.request_selected_files("open-1", "/tmp", multiple=True)
+    loop.request_selected_files("open-1")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    assert requests.file_selections[0].multiple is True
+    assert requests.file_selections[0].initial_path == str(Path.home())
 
 
 def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
@@ -186,6 +187,14 @@ def test_selected_file_policy_helpers() -> None:
     assert selected_file_suffix_allowed("seed.PNG", (".png",))
     assert not selected_file_suffix_allowed("seed.txt", (".png",))
     assert selected_file_suffix_allowed("seed.txt", ())
+    assert (
+        selected_file_policy_status("seed.txt", None, accept=(".png",), max_bytes=3)
+        is SelectedFilesStatus.DISALLOWED_TYPE
+    )
+    assert (
+        selected_file_policy_status("seed.png", None, accept=(".png",), max_bytes=3)
+        is None
+    )
     assert (
         selected_file_policy_status("seed.txt", 99, accept=(".png",), max_bytes=3)
         is SelectedFilesStatus.DISALLOWED_TYPE
@@ -232,6 +241,12 @@ def test_selected_file_policy_helpers() -> None:
     )
 
 
+def test_ui_loop_rejects_empty_request_id() -> None:
+    loop = _ui_loop()
+    with pytest.raises(ValueError, match="non-empty string"):
+        loop.request_selected_files("")
+
+
 def test_ui_loop_rejects_invalid_accept() -> None:
     loop = _ui_loop()
     with pytest.raises(ValueError, match="accept suffixes"):
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index dabf2981a..66f1dc8ab 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -314,19 +314,19 @@ async def test_in_flight_upload_is_dropped_after_peer_loss(
         peer, _, _ = await _connect_browser(window)
         window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
-        original_post = web.Request.post
+        original_multipart = web.Request.multipart
         disconnected = False
 
-        async def post_after_disconnect(request: web.Request) -> Any:
+        async def multipart_after_disconnect(request: web.Request) -> Any:
             nonlocal disconnected
             if not disconnected:
                 disconnected = True
                 peer_connection = window.server._peer_connection
                 if peer_connection is not None:
                     await window.server._release_peer_connection(peer_connection)
-            return await original_post(request)
+            return await original_multipart(request)
 
-        monkeypatch.setattr(web.Request, "post", post_after_disconnect)
+        monkeypatch.setattr(web.Request, "multipart", multipart_after_disconnect)
         assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
         events = []
         for _ in range(100):
@@ -517,7 +517,7 @@ async def test_file_upload_rejects_oversize() -> None:
 
 
 @pytest.mark.asyncio
-async def test_file_upload_prefers_disallowed_suffix_over_oversize() -> None:
+async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
@@ -526,7 +526,10 @@ async def test_file_upload_prefers_disallowed_suffix_over_oversize() -> None:
         )
         await _wait_file_armed(window, "open-1")
         assert (
-            await _post_selected_file(window, "open-1", b"x" * 8192, "hello.txt") == 204
+            await _post_selected_file(
+                window, "open-1", b"x" * (2 * 1024 * 1024), "hello.txt"
+            )
+            == 204
         )
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
@@ -564,6 +567,77 @@ async def test_browser_file_selector_result_reports_status() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_browser_file_selector_result_cannot_claim_ok() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, channel, _ = await _connect_browser(window)
+        errors: list[dict[str, object]] = []
+
+        @channel.on("message")
+        def on_message(message: object) -> None:
+            if isinstance(message, str):
+                payload = json.loads(message)
+                if payload.get("type") == "error":
+                    errors.append(payload)
+
+        window.request_selected_files(_file_request("open-1"))
+        await _wait_file_armed(window, "open-1")
+        channel.send(
+            json.dumps(
+                {
+                    "type": "file_selector_result",
+                    "id": "open-1",
+                    "status": "ok",
+                }
+            )
+        )
+        for _ in range(100):
+            if errors:
+                break
+            await asyncio.sleep(0.01)
+        assert errors
+        assert "POST /api/files" in str(errors[0].get("message"))
+        assert window.get_user_input_events().get_events() == []
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.OK
+        assert event.files[0].data == b"hello"
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_browser_script_checks_type_and_size_before_upload() -> None:
+    window = WebRTCClientWindow()
+    try:
+        async with ClientSession() as client:
+            async with client.get(window.server.url) as response:
+                page = await response.text()
+                assert 'id="prompt-dialog"' in page
+                assert "Choose file" not in page
+            async with client.get(f"{window.server.url}app.js") as response:
+                script = await response.text()
+        assert "fileNameMatchesAccept" in script
+        assert "file.size" in script
+        assert '"too_large"' in script
+        assert '"disallowed_type"' in script
+        assert (
+            "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`" in script
+        )
+        assert "input.multiple" in script
+        assert "showModal" not in script
+        assert "The app requested a file" in script
+        assert "The app requested files" in script
+        assert 'completeFileSelection(pendingFileRequest.id, "cancelled")' not in script
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_session_handoff_clears_pending_file_selection() -> None:
     window = WebRTCClientWindow()
@@ -589,17 +663,17 @@ async def test_in_flight_upload_is_dropped_after_session_handoff(
     try:
         window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
-        original_post = web.Request.post
+        original_multipart = web.Request.multipart
         handed_off = False
 
-        async def post_after_handoff(request: web.Request) -> Any:
+        async def multipart_after_handoff(request: web.Request) -> Any:
             nonlocal handed_off
             if not handed_off:
                 handed_off = True
                 window.open(_session_desc())
-            return await original_post(request)
+            return await original_multipart(request)
 
-        monkeypatch.setattr(web.Request, "post", post_after_handoff)
+        monkeypatch.setattr(web.Request, "multipart", multipart_after_handoff)
         assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
         assert window.get_user_input_events().get_events() == []
 
@@ -660,10 +734,6 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert 'id="reset"' not in browser_page
                 assert '<video id="video" autoplay muted playsinline>' in browser_page
                 assert 'id="status"' in browser_page
-                assert 'id="prompt-dialog"' in browser_page
-                assert 'id="prompt-dialog-confirm"' in browser_page
-                assert 'id="prompt-dialog-details"' in browser_page
-                assert 'id="prompt-backdrop"' in browser_page
                 assert '<script src="/app.js"></script>' in browser_page
             async with client.get(f"{window.server.url}app.js") as response:
                 browser_script = await response.text()
@@ -700,33 +770,6 @@ async def test_window_buffers_browser_events_until_drained() -> None:
                 assert '["failed", "closed"]' in connection_handler
                 assert "navigator.getGamepads" in browser_script
                 assert 'type: "touch"' in browser_script
-                assert "openFileSelector" in browser_script
-                assert 'type === "file_selector"' in browser_script
-                assert "completeFileSelection" in browser_script
-                assert (
-                    'completeFileSelection(pendingFileRequest.id, "cancelled")'
-                    not in browser_script
-                )
-                assert "queuedFileSelectors" in browser_script
-                assert '"too_large"' in browser_script
-                assert '"disallowed_type"' in browser_script
-                assert (
-                    "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`"
-                    in browser_script
-                )
-                assert "input.accept" in browser_script
-                assert "input.multiple" in browser_script
-                assert "file.size" in browser_script
-                assert 'addEventListener("cancel"' in browser_script
-                assert "fileNameMatchesAccept" in browser_script
-                assert "showPromptDialog" in browser_script
-                assert "showModal" not in browser_script
-                assert "The app requested a file" in browser_script
-                assert "The app requested files" in browser_script
-                assert 'label: "Accepted types"' in browser_script
-                assert 'label: "Max size per file"' in browser_script
-                assert "Choose file" not in browser_page
-                assert "response.ok" in browser_script
 
         window.request_hide_cursor(True)
         window.open(_session_desc())

From d4ebdbbd56692a5ef877947ff94a987681bb8647 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 5 Oct 2026 15:48:06 -0700
Subject: [PATCH 21/43] Decode multipart transfer encoding and unblock CPU
 lint.

A base64 Content-Transfer-Encoding part must yield the file bytes, not
the encoded payload. Import sort and a ty ignore were failing the CPU job.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/loop.py        |  2 +-
 .../runtime_v2/serving/webrtc_server.py       | 19 +++++-----
 flashdreams/test_v2/test_selected_files.py    |  2 +-
 .../test_v2/test_webrtc_client_window.py      | 36 +++++++++++++++++--
 .../imgui_ui_demo/file_picker_app.py          |  4 +--
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  2 +-
 6 files changed, 49 insertions(+), 16 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index ad1a22f9e..f06c4cfee 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -20,11 +20,11 @@
 from torch import Tensor
 
 from flashdreams.runtime_v2.event_buffer import EventBuffer
-from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.selected_file import (
     FileSelectionRequest,
     normalize_selected_file_accept,
 )
+from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
     UserInputEvent,
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index b113f1056..253406bfc 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -1542,15 +1542,14 @@ async def _shutdown(self) -> None:
 async def _read_upload_part_bounded(
     part: BodyPartReader, *, max_bytes: int
 ) -> bytes | None:
-    """Return the part body, or ``None`` when it exceeds ``max_bytes``.
+    """Return the decoded part body, or ``None`` when it exceeds ``max_bytes``.
 
     Args:
         part: Multipart file part whose headers have already been read.
-        max_bytes: Maximum allowed size of this file in bytes.
+        max_bytes: Maximum allowed size of the decoded file in bytes.
 
     Returns:
-        The assembled bytes, or ``None`` when the part is larger than
-        ``max_bytes``.
+        The decoded bytes, or ``None`` when they exceed ``max_bytes``.
     """
     chunks: list[bytes] = []
     total = 0
@@ -1558,11 +1557,13 @@ async def _read_upload_part_bounded(
         chunk = await part.read_chunk(_UPLOAD_READ_CHUNK_BYTES)
         if not chunk:
             break
-        total += len(chunk)
-        if total > max_bytes:
-            await part.release()
-            return None
-        chunks.append(chunk)
+        async for decoded in part.decode_iter(chunk):
+            piece = bytes(decoded)
+            total += len(piece)
+            if total > max_bytes:
+                await part.release()
+                return None
+            chunks.append(piece)
     return b"".join(chunks)
 
 
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index b1facf7db..5804f5c9e 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -256,7 +256,7 @@ def test_ui_loop_rejects_invalid_accept() -> None:
 def test_ui_loop_rejects_invalid_multiple() -> None:
     loop = _ui_loop()
     with pytest.raises(TypeError, match="multiple must be a bool"):
-        loop.request_selected_files("open-1", multiple=1)  # type: ignore[arg-type]
+        loop.request_selected_files("open-1", multiple=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
 
 
 def test_selected_files_event_rejects_inconsistent_status() -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 66f1dc8ab..51c74690e 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -6,6 +6,7 @@
 # ruff: noqa: E402 - optional WebRTC imports must follow importorskip.
 
 import asyncio
+import base64
 import json
 import time
 from dataclasses import replace
@@ -31,13 +32,13 @@
 from av import VideoFrame
 from yarl import URL
 
-from flashdreams.runtime_v2.serving import webrtc_server
-from flashdreams.runtime_v2.serving.webrtc_server import _VideoTrack
 from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BYTES,
     FileSelectionRequest,
     SelectedFilesStatus,
 )
+from flashdreams.runtime_v2.serving import webrtc_server
+from flashdreams.runtime_v2.serving.webrtc_server import _VideoTrack
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
@@ -516,6 +517,37 @@ async def test_file_upload_rejects_oversize() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_file_upload_decodes_base64_transfer_encoding() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(_file_request("open-1"))
+        await _wait_file_armed(window, "open-1")
+        boundary = "----flashdreams"
+        body = (
+            f"--{boundary}\r\n"
+            'Content-Disposition: form-data; name="file"; filename="seed.bin"\r\n'
+            "Content-Transfer-Encoding: base64\r\n"
+            "\r\n"
+            f"{base64.b64encode(b'abc').decode()}\r\n"
+            f"--{boundary}--\r\n"
+        ).encode()
+        async with ClientSession() as client:
+            async with client.post(
+                _files_url(window, "open-1"),
+                data=body,
+                headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
+            ) as response:
+                assert response.status == 204
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.OK
+        assert event.files[0].name == "seed.bin"
+        assert event.files[0].data == b"abc"
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
     window = WebRTCClientWindow()
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index c403064c9..47fee1681 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -15,12 +15,12 @@
 from flashdreams.api_v2.loop import IModelLoop
 from flashdreams.api_v2.session import ISession
 from flashdreams.runtime_v2.imgui_ui_loop import ImGuiUILoop
-from flashdreams.runtime_v2.session_desc import SessionDesc
-from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BYTES,
     SelectedFilesStatus,
 )
+from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 58c793424..14a09216d 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -26,12 +26,12 @@
 from numpy import uint64
 
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
-from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BYTES,
     SelectedFile,
     SelectedFilesStatus,
 )
+from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 

From eda40c904794bf9ebb289d44075c513959aba030 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 6 Oct 2026 16:48:59 -0700
Subject: [PATCH 22/43] Expose client file selection as an every-tick
 IUILoop.file_selector

Call file_selector every UI tick with a stable request_id and open= on the
activation frame; it returns this tick's SelectedFilesUserInputEvent or None.
Rename max_bytes to max_file_bytes on the app-facing call and point docs at
the per-file and batch cap constants.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  22 ++--
 flashdreams/flashdreams/api_v2/loop.py        | 123 ++++++++++--------
 .../runtime_v2/user_input_event.py            |   8 +-
 flashdreams/test_v2/test_selected_files.py    |  52 ++++++--
 flashdreams/test_v2/test_session_runner.py    |  14 +-
 integrations_v2/imgui_ui_demo/README.md       |  15 ++-
 .../imgui_ui_demo/file_picker_app.py          |  74 +++++++----
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  73 +++++------
 8 files changed, 227 insertions(+), 154 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index bbc8275f8..676acbb49 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -224,16 +224,18 @@ UI control that needs a fresh application session calls
 `request_new_session(session_desc)` with a fully resolved replacement
 description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. Remaining timeout and remaining model steps
-still apply to the replacement. A control that needs a file from the client calls
-`request_selected_files(request_id, accept=..., max_bytes=..., multiple=...)`.
-The window later reports `SelectedFilesUserInputEvent` on the same input stream
-as keyboard and mouse. Read `status`; use `files` only when the pick succeeded.
-`request_id` is a stable id for which button made the request and is
-echoed on that event. Reuse it every time that button is pressed so a
-second click is the same request, not another picker; use a different
-id for a different button. `accept` is filename suffixes (empty = any type);
-`max_bytes` is the size budget per file (`None` = the 32 MiB ceiling);
-`multiple` allows more than one file.
+still apply to the replacement. A control that needs a file from the client
+calls `file_selector` every UI tick with a stable `request_id`.
+Pass `open=True` only when that control was activated this tick (for ImGui,
+`open=imgui.button(...)`). The call returns this tick's
+`SelectedFilesUserInputEvent` for that id, or `None`. Read `status`; use
+`files` only when the pick succeeded. Reuse the same `request_id` for the
+same control so extra clicks do not stack pickers; use a different id for a
+different control. `accept` is filename suffixes (empty = any type);
+`max_file_bytes` is the size budget per file (`None` = the
+`MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
+the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
+`runtime_v2/selected_file.py`.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 52c1dafaa..f83f9ce5b 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -27,6 +27,7 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
+    SelectedFilesUserInputEvent,
     UserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
@@ -536,78 +537,98 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         self.get_or_create_ui_loop_requests().new_window_size = new_window_size
 
     @final
-    def request_selected_files(
+    def file_selector(
         self,
         request_id: str,
         initial_path: str | None = None,
         *,
+        open: bool = False,
         accept: Sequence[str] = (),
-        max_bytes: int | None = None,
+        max_file_bytes: int | None = None,
         multiple: bool = False,
-    ) -> None:
-        """Request that the client window open a file selector local to the client.
+    ) -> SelectedFilesUserInputEvent | None:
+        """Drive one client file-selector control and return this tick's result.
 
-        The result arrives later as
-        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`
-        with this ``request_id``. Read ``status`` to see whether the pick
-        succeeded; use ``files`` only when it did.
+        Call every UI tick for each control. Pass ``open=True`` only when
+        that control was activated this tick. ``request_id`` is which
+        control this is: reuse it so extra clicks do not stack pickers;
+        use a different id for a different control.
 
         Args:
-            request_id: Stable id for which button this request is for. Reuse
-                it every time that button is pressed so a second click is the
-                same request, not another picker. Use a different id for a
-                different button so the later event can be told apart.
+            request_id: Stable id for this control. Echoed on the matching event.
             initial_path: Directory hint for the selector; ``None`` uses the
                 current user's home directory.
+            open: Whether to start a selector this tick.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
-            max_bytes: Maximum size of each file in bytes, or ``None`` for the
-                ceiling.
-            multiple: Whether the selector may return more than one file.
+            max_file_bytes: Maximum size of each file in bytes, or ``None`` for
+                the ceiling. Larger values clamp to
+                :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BYTES`.
+            multiple: Whether the selector may return more than one file. The
+                whole set is also capped by
+                :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BATCH_BYTES`.
+
+        Returns:
+            This tick's selected-files event for ``request_id``, or ``None``.
+            Read ``status``; use ``files`` only when the pick succeeded.
 
         Raises:
             TypeError: ``request_id`` or ``initial_path`` is not a string, or
-                ``accept`` / ``max_bytes`` / ``multiple`` has the wrong type.
+                ``open`` / ``accept`` / ``max_file_bytes`` / ``multiple`` has
+                the wrong type.
             ValueError: ``request_id`` is empty, ``initial_path`` is empty, or
-                ``accept`` / ``max_bytes`` is invalid.
+                ``accept`` / ``max_file_bytes`` is invalid.
         """
         if not isinstance(request_id, str):
             raise TypeError("request_id must be a string.")
         if not request_id:
             raise ValueError("request_id must be a non-empty string.")
-        if initial_path is None:
-            resolved_initial_path = str(Path.home())
-        else:
-            if not isinstance(initial_path, str):
-                raise TypeError("initial_path must be a string.")
-            if not initial_path:
-                raise ValueError("initial_path must be a non-empty string.")
-            resolved_initial_path = initial_path
-        suffixes = normalize_selected_file_accept(accept)
-        if max_bytes is not None:
-            if isinstance(max_bytes, bool) or not isinstance(max_bytes, int):
-                raise TypeError("max_bytes must be an integer.")
-            if max_bytes <= 0:
-                raise ValueError("max_bytes must be > 0.")
-        if not isinstance(multiple, bool):
-            raise TypeError("multiple must be a bool.")
-        requests = self.get_or_create_ui_loop_requests()
-        if any(
-            selection.request_id == request_id for selection in requests.file_selections
-        ):
-            _LOGGER.warning(
-                "Ignoring duplicate file-selection request id %r.",
-                request_id,
-            )
-            return
-        requests.file_selections.append(
-            FileSelectionRequest(
-                request_id=request_id,
-                initial_path=resolved_initial_path,
-                accept=suffixes,
-                max_bytes=max_bytes,
-                multiple=multiple,
-            )
-        )
+        if not isinstance(open, bool):
+            raise TypeError("open must be a bool.")
+        if open:
+            if initial_path is None:
+                resolved_initial_path = str(Path.home())
+            else:
+                if not isinstance(initial_path, str):
+                    raise TypeError("initial_path must be a string.")
+                if not initial_path:
+                    raise ValueError("initial_path must be a non-empty string.")
+                resolved_initial_path = initial_path
+            suffixes = normalize_selected_file_accept(accept)
+            if max_file_bytes is not None:
+                if isinstance(max_file_bytes, bool) or not isinstance(
+                    max_file_bytes, int
+                ):
+                    raise TypeError("max_file_bytes must be an integer.")
+                if max_file_bytes <= 0:
+                    raise ValueError("max_file_bytes must be > 0.")
+            if not isinstance(multiple, bool):
+                raise TypeError("multiple must be a bool.")
+            requests = self.get_or_create_ui_loop_requests()
+            if any(
+                selection.request_id == request_id
+                for selection in requests.file_selections
+            ):
+                _LOGGER.warning(
+                    "Ignoring duplicate file-selection request id %r.",
+                    request_id,
+                )
+            else:
+                requests.file_selections.append(
+                    FileSelectionRequest(
+                        request_id=request_id,
+                        initial_path=resolved_initial_path,
+                        accept=suffixes,
+                        max_bytes=max_file_bytes,
+                        multiple=multiple,
+                    )
+                )
+        for event in self.user_events.get_events():
+            if (
+                isinstance(event, SelectedFilesUserInputEvent)
+                and event.request_id == request_id
+            ):
+                return event
+        return None
 
     def get_or_create_ui_loop_requests(self) -> UILoopRequests:
         if self._ui_loop_requests is None:
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 2dac1b55a..089e72608 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -233,10 +233,10 @@ def get_type_name(cls) -> str:
 
 @dataclass(frozen=True, slots=True, eq=False)
 class SelectedFilesUserInputEvent(UserInputEvent):
-    """Files chosen for one :meth:`IClientWindow.request_selected_files` call.
+    """Result of one file-selector request.
 
-    ``status`` is why the request completed. ``OK`` is the only value with
-    files; every other value uses an empty ``files`` tuple.
+    Applications receive it from :meth:`IUILoop.file_selector`.
+    ``OK`` is the only status with files; every other status has empty ``files``.
     """
 
     @classmethod
@@ -245,7 +245,7 @@ def get_type_name(cls) -> str:
         return "selected_files"
 
     request_id: str
-    """Stable id for which button this result is for. Same string the UI passed when it asked."""
+    """``request_id`` of the control that asked for this result."""
 
     status: SelectedFilesStatus
     """Why this request completed. ``OK`` is the only value with files."""
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 5804f5c9e..e45be8f62 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -78,14 +78,15 @@ def test_selected_files_event_carries_bytes_and_request_id() -> None:
 
 def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     loop = _ui_loop()
-    loop.request_selected_files(
+    loop.file_selector(
         "open-1",
         "/tmp",
+        open=True,
         accept=(".png", ".JPG"),
-        max_bytes=MAX_SELECTED_FILE_BYTES * 2,
+        max_file_bytes=MAX_SELECTED_FILE_BYTES * 2,
         multiple=True,
     )
-    loop.request_selected_files("open-1", "/var")
+    loop.file_selector("open-1", "/var", open=True)
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
@@ -100,7 +101,7 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
 
 def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
     loop = _ui_loop()
-    loop.request_selected_files("open-1")
+    loop.file_selector("open-1", open=True)
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
@@ -109,8 +110,8 @@ def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
 
 def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
     loop = _ui_loop()
-    loop.request_selected_files("open-1", "/tmp")
-    loop.request_selected_files("open-2", "/var")
+    loop.file_selector("open-1", "/tmp", open=True)
+    loop.file_selector("open-2", "/var", open=True)
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
@@ -241,22 +242,55 @@ def test_selected_file_policy_helpers() -> None:
     )
 
 
+def test_ui_loop_does_not_queue_when_open_is_false() -> None:
+    loop = _ui_loop()
+    assert loop.file_selector("open-1") is None
+    assert loop.flush_ui_loop_requests() is None
+
+
+def test_ui_loop_returns_this_tick_selected_files_event() -> None:
+    loop = _ui_loop()
+    event = SelectedFilesUserInputEvent(
+        timestamp=uint64(1),
+        request_id="open-1",
+        status=SelectedFilesStatus.OK,
+        files=(SelectedFile(name="seed.png", data=b"png"),),
+    )
+    other = SelectedFilesUserInputEvent(
+        timestamp=uint64(2),
+        request_id="open-2",
+        status=SelectedFilesStatus.CANCELLED,
+    )
+    loop.user_events = UserInputEvents([event, other])
+
+    assert loop.file_selector("open-1") is event
+    assert loop.file_selector("open-2") is other
+    assert loop.file_selector("open-3") is None
+    assert loop.flush_ui_loop_requests() is None
+
+
 def test_ui_loop_rejects_empty_request_id() -> None:
     loop = _ui_loop()
     with pytest.raises(ValueError, match="non-empty string"):
-        loop.request_selected_files("")
+        loop.file_selector("")
 
 
 def test_ui_loop_rejects_invalid_accept() -> None:
     loop = _ui_loop()
     with pytest.raises(ValueError, match="accept suffixes"):
-        loop.request_selected_files("open-1", accept=("png",))
+        loop.file_selector("open-1", open=True, accept=("png",))
 
 
 def test_ui_loop_rejects_invalid_multiple() -> None:
     loop = _ui_loop()
     with pytest.raises(TypeError, match="multiple must be a bool"):
-        loop.request_selected_files("open-1", multiple=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+        loop.file_selector("open-1", open=True, multiple=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+
+
+def test_ui_loop_rejects_invalid_open() -> None:
+    loop = _ui_loop()
+    with pytest.raises(TypeError, match="open must be a bool"):
+        loop.file_selector("open-1", open=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
 
 
 def test_selected_files_event_rejects_inconsistent_status() -> None:
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index a7d772f51..3b3ff3297 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -1383,15 +1383,17 @@ def test_run_session_forwards_file_selection_requests_to_the_window() -> None:
     class RequestingSession(FakeSession):
         def init(self) -> None:
             super().init()
-            invoke_async(
-                self.ui_loop,
-                lambda _: self.ui_loop.request_selected_files(
+
+            def open_selector(_: object) -> None:
+                self.ui_loop.file_selector(
                     "open-1",
                     "/tmp",
+                    open=True,
                     accept=(".png",),
-                    max_bytes=1024,
-                ),
-            )
+                    max_file_bytes=1024,
+                )
+
+            invoke_async(self.ui_loop, open_selector)
 
     window = RecordingClientWindow(log)
     run_session(RequestingSession(_session_desc(), log), window, steps=1)
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index 887b5ec0b..e11aefa35 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -9,11 +9,12 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
 
 - `imgui-ui-text-input` renders an editable text field over model output.
 - `imgui-ui-file-picker` opens the client file selector and shows the chosen
-  name and size (the file bytes are on the event; apps should use those).
-  Each Open control uses a stable `request_id`. Extra clicks on the same
-  control while a picker is open are ignored; **Open A then B** queues both
-  selectors one at a time. Closing the native window or dropping the WebRTC
-  tab completes leftover and in-flight picks as unavailable.
+  name and size. Each Open control calls `file_selector` every UI tick with
+  a stable `request_id`; the returned event carries the file bytes. Extra
+  clicks on the same control while a picker is open are ignored;
+  **Open A then B** queues both selectors one at a time. Closing the native
+  window or dropping the WebRTC tab completes leftover and in-flight picks
+  as unavailable.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.
@@ -33,8 +34,8 @@ uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 Run the file-picker application. Native Linux needs `zenity` or `kdialog`
 (the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
 confirmation dialog in the viewer (the picker must open from a browser click).
-The demo asks for `.bin` / `.raw` at the 32 MiB ceiling. Controls are
-**Open file (A)**, **Open file (B)**, **Open A then B**, and **Open files**
+The demo asks for `.bin` / `.raw` at the per-file ceiling
+(`MAX_SELECTED_FILE_BYTES`). Controls are **Open file (A)**, **Open file (B)**, **Open A then B**, and **Open files**
 (more than one file). Failed picks show in red with the
 `SelectedFilesStatus` name and why.
 ```bash
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 47fee1681..ae279b615 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -40,7 +40,7 @@
     ),
     SelectedFilesStatus.TOO_LARGE: (
         "SelectedFilesStatus.TOO_LARGE: file exceeded this request's "
-        f"max_bytes={MAX_SELECTED_FILE_BYTES} (32 MiB)."
+        f"max_file_bytes={MAX_SELECTED_FILE_BYTES}."
     ),
     SelectedFilesStatus.DISALLOWED_TYPE: (
         "SelectedFilesStatus.DISALLOWED_TYPE: suffix not in accept=('.bin', '.raw')."
@@ -122,31 +122,35 @@ def step_ui(
         step_index: int,
         events: UserInputEvents,
     ) -> Tensor | None:
-        """Draw the Open-file control and apply any selected-files events."""
-        del step_index
-        for event in events.get_events():
-            if not isinstance(event, SelectedFilesUserInputEvent):
-                continue
-            if event.status is not SelectedFilesStatus.OK:
-                self.state.status = _FILE_SELECTION_STATUS_TEXT[event.status]
-                continue
-            self.state.status = ", ".join(
-                f"{chosen.name} ({len(chosen.data)} bytes)" for chosen in event.files
-            )
-
+        """Draw the Open-file controls and apply this tick's selector results."""
+        del step_index, events
         imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
         imgui.set_next_window_size(imgui.ImVec2(520.0, 300.0), imgui.Cond_.once)
         imgui.begin("File picker")
         try:
-            if imgui.button(_OPEN_FILE_A_LABEL):
-                self._request_demo_file(_OPEN_FILE_A_REQUEST_ID)
-            if imgui.button(_OPEN_FILE_B_LABEL):
-                self._request_demo_file(_OPEN_FILE_B_REQUEST_ID)
-            if imgui.button(_OPEN_A_THEN_B_LABEL):
-                self._request_demo_file(_OPEN_FILE_A_REQUEST_ID)
-                self._request_demo_file(_OPEN_FILE_B_REQUEST_ID)
-            if imgui.button(_OPEN_FILES_LABEL):
-                self._request_demo_file(_OPEN_FILES_REQUEST_ID, multiple=True)
+            clicked_a = imgui.button(_OPEN_FILE_A_LABEL)
+            clicked_b = imgui.button(_OPEN_FILE_B_LABEL)
+            clicked_a_then_b = imgui.button(_OPEN_A_THEN_B_LABEL)
+            clicked_files = imgui.button(_OPEN_FILES_LABEL)
+            self._apply_demo_pick(
+                self._request_demo_file(
+                    _OPEN_FILE_A_REQUEST_ID,
+                    open=clicked_a or clicked_a_then_b,
+                )
+            )
+            self._apply_demo_pick(
+                self._request_demo_file(
+                    _OPEN_FILE_B_REQUEST_ID,
+                    open=clicked_b or clicked_a_then_b,
+                )
+            )
+            self._apply_demo_pick(
+                self._request_demo_file(
+                    _OPEN_FILES_REQUEST_ID,
+                    open=clicked_files,
+                    multiple=True,
+                )
+            )
             if self.state.status in _FILE_SELECTION_STATUS_TEXT.values():
                 imgui.push_style_color(
                     imgui.Col_.text,
@@ -162,15 +166,33 @@ def step_ui(
             imgui.end()
         return self.presented_model_frame()
 
-    def _request_demo_file(self, request_id: str, *, multiple: bool = False) -> None:
-        """Ask for a ``.bin`` / ``.raw`` pick on one selector slot."""
-        self.request_selected_files(
+    def _request_demo_file(
+        self,
+        request_id: str,
+        *,
+        open: bool,
+        multiple: bool = False,
+    ) -> SelectedFilesUserInputEvent | None:
+        """Poll one ``.bin`` / ``.raw`` selector slot and optionally start it."""
+        return self.file_selector(
             request_id,
+            open=open,
             accept=(".bin", ".raw"),
-            max_bytes=MAX_SELECTED_FILE_BYTES,
+            max_file_bytes=MAX_SELECTED_FILE_BYTES,
             multiple=multiple,
         )
 
+    def _apply_demo_pick(self, event: SelectedFilesUserInputEvent | None) -> None:
+        """Show this tick's selector result on the overlay."""
+        if event is None:
+            return
+        if event.status is not SelectedFilesStatus.OK:
+            self.state.status = _FILE_SELECTION_STATUS_TEXT[event.status]
+            return
+        self.state.status = ", ".join(
+            f"{chosen.name} ({len(chosen.data)} bytes)" for chosen in event.files
+        )
+
     def reset(self) -> None:
         """Clear the last selector result for a new generation."""
         self.state.status = "No file selected."
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 14a09216d..2a9daa93e 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -160,20 +160,17 @@ def test_selected_files_event_updates_file_picker_status() -> None:
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()
 
-    loop.step_ui(
-        imgui,
-        0,
-        UserInputEvents(
-            [
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id="open-1",
-                    status=SelectedFilesStatus.OK,
-                    files=(SelectedFile(name="seed.png", data=b"xx"),),
-                )
-            ]
-        ),
+    loop.user_events = UserInputEvents(
+        [
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=_OPEN_FILE_A_REQUEST_ID,
+                status=SelectedFilesStatus.OK,
+                files=(SelectedFile(name="seed.png", data=b"xx"),),
+            )
+        ]
     )
+    loop.step_ui(imgui, 0, loop.user_events)
 
     assert state.status == "seed.png (2 bytes)"
     imgui.text.assert_called_with("seed.png (2 bytes)")
@@ -185,23 +182,20 @@ def test_selected_files_event_lists_every_chosen_file() -> None:
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()
 
-    loop.step_ui(
-        imgui,
-        0,
-        UserInputEvents(
-            [
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id=_OPEN_FILES_REQUEST_ID,
-                    status=SelectedFilesStatus.OK,
-                    files=(
-                        SelectedFile(name="a.bin", data=b"aa"),
-                        SelectedFile(name="b.raw", data=b"bbb"),
-                    ),
-                )
-            ]
-        ),
+    loop.user_events = UserInputEvents(
+        [
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=_OPEN_FILES_REQUEST_ID,
+                status=SelectedFilesStatus.OK,
+                files=(
+                    SelectedFile(name="a.bin", data=b"aa"),
+                    SelectedFile(name="b.raw", data=b"bbb"),
+                ),
+            )
+        ]
     )
+    loop.step_ui(imgui, 0, loop.user_events)
 
     assert state.status == "a.bin (2 bytes), b.raw (3 bytes)"
     imgui.text.assert_called_with("a.bin (2 bytes), b.raw (3 bytes)")
@@ -217,19 +211,16 @@ def test_file_picker_shows_error_status_in_red() -> None:
     imgui = _file_picker_imgui()
     cancelled = SelectedFilesStatus.CANCELLED
 
-    loop.step_ui(
-        imgui,
-        0,
-        UserInputEvents(
-            [
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id="open-1",
-                    status=cancelled,
-                )
-            ]
-        ),
+    loop.user_events = UserInputEvents(
+        [
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=_OPEN_FILE_A_REQUEST_ID,
+                status=cancelled,
+            )
+        ]
     )
+    loop.step_ui(imgui, 0, loop.user_events)
 
     message = _FILE_SELECTION_STATUS_TEXT[cancelled]
     assert state.status == message

From 12ad58ba0f256207b70c0c30b03befb179d703b5 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 09:42:53 -0700
Subject: [PATCH 23/43] Reject one request_id used by two file_selector
 controls in a tick

Raise ValueError when file_selector sees the same request_id twice before
the next flush. Repeat clicks across ticks are still dropped by the window
gate, so the same-tick drop in IUILoop is removed.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  2 +-
 flashdreams/flashdreams/api_v2/loop.py        | 41 ++++++++-----------
 flashdreams/test_v2/test_selected_files.py    | 14 ++++++-
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  1 -
 4 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 676acbb49..1da196d79 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -231,7 +231,7 @@ Pass `open=True` only when that control was activated this tick (for ImGui,
 `SelectedFilesUserInputEvent` for that id, or `None`. Read `status`; use
 `files` only when the pick succeeded. Reuse the same `request_id` for the
 same control so extra clicks do not stack pickers; use a different id for a
-different control. `accept` is filename suffixes (empty = any type);
+different control (one id used twice in a tick raises `ValueError`). `accept` is filename suffixes (empty = any type);
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index f83f9ce5b..4f5482cf5 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import logging
 import queue
 import threading
 import time
@@ -38,8 +37,6 @@
 
 StateT = TypeVar("StateT")
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class _ModelStepControl(Protocol):
     """Private execution hook for step admission and synchronized input."""
@@ -475,6 +472,7 @@ def register_session_ui_loop_objects(
         self._presentation_manager = presentation_manager
 
         self._ui_loop_requests: UILoopRequests | None = None
+        self._file_selector_ids: set[str] = set()
 
     @final
     def _set_model_loop(self, model_loop: IModelLoop[Any]) -> None:
@@ -575,8 +573,9 @@ def file_selector(
             TypeError: ``request_id`` or ``initial_path`` is not a string, or
                 ``open`` / ``accept`` / ``max_file_bytes`` / ``multiple`` has
                 the wrong type.
-            ValueError: ``request_id`` is empty, ``initial_path`` is empty, or
-                ``accept`` / ``max_file_bytes`` is invalid.
+            ValueError: ``request_id`` is empty or already used this tick,
+                ``initial_path`` is empty, or ``accept`` / ``max_file_bytes``
+                is invalid.
         """
         if not isinstance(request_id, str):
             raise TypeError("request_id must be a string.")
@@ -584,6 +583,10 @@ def file_selector(
             raise ValueError("request_id must be a non-empty string.")
         if not isinstance(open, bool):
             raise TypeError("open must be a bool.")
+        if request_id in self._file_selector_ids:
+            raise ValueError(
+                f"request_id {request_id!r} is used by more than one control."
+            )
         if open:
             if initial_path is None:
                 resolved_initial_path = str(Path.home())
@@ -603,25 +606,16 @@ def file_selector(
                     raise ValueError("max_file_bytes must be > 0.")
             if not isinstance(multiple, bool):
                 raise TypeError("multiple must be a bool.")
-            requests = self.get_or_create_ui_loop_requests()
-            if any(
-                selection.request_id == request_id
-                for selection in requests.file_selections
-            ):
-                _LOGGER.warning(
-                    "Ignoring duplicate file-selection request id %r.",
-                    request_id,
-                )
-            else:
-                requests.file_selections.append(
-                    FileSelectionRequest(
-                        request_id=request_id,
-                        initial_path=resolved_initial_path,
-                        accept=suffixes,
-                        max_bytes=max_file_bytes,
-                        multiple=multiple,
-                    )
+            self.get_or_create_ui_loop_requests().file_selections.append(
+                FileSelectionRequest(
+                    request_id=request_id,
+                    initial_path=resolved_initial_path,
+                    accept=suffixes,
+                    max_bytes=max_file_bytes,
+                    multiple=multiple,
                 )
+            )
+        self._file_selector_ids.add(request_id)
         for event in self.user_events.get_events():
             if (
                 isinstance(event, SelectedFilesUserInputEvent)
@@ -639,6 +633,7 @@ def flush_ui_loop_requests(self) -> UILoopRequests | None:
         """return UI loop requests and clear the internal state of requests."""
         requests = self._ui_loop_requests
         self._ui_loop_requests = None
+        self._file_selector_ids.clear()
         return requests
 
     @final
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index e45be8f62..c9a6ce0d4 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -86,7 +86,6 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
         max_file_bytes=MAX_SELECTED_FILE_BYTES * 2,
         multiple=True,
     )
-    loop.file_selector("open-1", "/var", open=True)
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
@@ -99,6 +98,19 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     assert selection.multiple is True
 
 
+def test_ui_loop_rejects_request_id_reused_in_one_tick() -> None:
+    loop = _ui_loop()
+    loop.file_selector("open-1")
+    with pytest.raises(ValueError, match="more than one control"):
+        loop.file_selector("open-1", open=True)
+
+    loop.flush_ui_loop_requests()
+    loop.file_selector("open-1", open=True)
+    requests = loop.flush_ui_loop_requests()
+    assert requests is not None
+    assert [item.request_id for item in requests.file_selections] == ["open-1"]
+
+
 def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
     loop = _ui_loop()
     loop.file_selector("open-1", open=True)
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 2a9daa93e..5f38b774b 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -116,7 +116,6 @@ def test_open_file_button_requests_a_client_file(label: str, request_id: str) ->
     imgui = _file_picker_imgui(pressed=label)
 
     loop.step_ui(imgui, 0, UserInputEvents([]))
-    loop.step_ui(imgui, 1, UserInputEvents([]))
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None

From 7cd6260a75911c2353125ecbcb98ba10f158cc3b Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 10:17:36 -0700
Subject: [PATCH 24/43] Require every IClientWindow to answer file selection
 requests

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 apps/action2v/tests/test_application.py       |  4 ++++
 apps/t2v/t2v/testing.py                       | 21 ++----------------
 apps/t2v/tests/test_cli.py                    |  4 ++++
 .../flashdreams/api_v2/client_window.py       |  7 +++---
 .../test_v2/test_application_runner.py        |  4 ++++
 flashdreams/test_v2/test_cli.py               |  4 ++++
 flashdreams/test_v2/test_client_window.py     | 22 +++++++++++++++++++
 .../red_screen/tests/test_red_screen.py       |  4 ++++
 tests/test_step_agreement.py                  |  3 +++
 9 files changed, 51 insertions(+), 22 deletions(-)

diff --git a/apps/action2v/tests/test_application.py b/apps/action2v/tests/test_application.py
index c767d5950..d5ab5f410 100644
--- a/apps/action2v/tests/test_application.py
+++ b/apps/action2v/tests/test_application.py
@@ -22,6 +22,7 @@
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.session_runner import run_session
 from flashdreams.runtime_v2.step_result import StepResult
@@ -142,6 +143,9 @@ def open(self, session_desc: SessionDesc) -> None:
         del session_desc
         self.opened = True
 
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        del request
+
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         assert self.opened
         self.cursor_requests.append(("hide", hide_cursor))
diff --git a/apps/t2v/t2v/testing.py b/apps/t2v/t2v/testing.py
index 648639a68..548e68a01 100644
--- a/apps/t2v/t2v/testing.py
+++ b/apps/t2v/t2v/testing.py
@@ -20,12 +20,12 @@
 import numpy.typing as npt
 import torch
 
-from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.runtime_v2.blit_model_output_to_screen_loop import (
     BlitModelOutputToScreenLoop,
 )
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
+from flashdreams.runtime_v2.null_client_window import NullClientWindow
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -33,7 +33,6 @@
 )
 from flashdreams.runtime_v2.session_runner import run_session
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
 from t2v.application import T2VApplication
 from t2v.ui import T2VImGuiUILoop
@@ -169,7 +168,7 @@ def check_t2v_model_impl(
         ):
             run_session(
                 application.create_session(session_desc),
-                _DiscardingClientWindow(),
+                NullClientWindow(),
                 metrics_output_sink=inspector,
                 steps=steps,
             )
@@ -404,22 +403,6 @@ def close(self) -> None:
             self._mp4.close()
 
 
-class _DiscardingClientWindow(IClientWindow):
-    """Drive a checked run without retaining its composed UI output."""
-
-    def get_user_input_events(self) -> UserInputEvents:
-        return UserInputEvents([])
-
-    def open(self, session_desc: SessionDesc) -> None:
-        del session_desc
-
-    def write(self, result: StepResult) -> None:
-        del result
-
-    def close(self) -> None:
-        return
-
-
 def _compare(
     inspector: _FrameInspector,
     expected: ExpectedFrameStats,
diff --git a/apps/t2v/tests/test_cli.py b/apps/t2v/tests/test_cli.py
index 144217b65..48de638c9 100644
--- a/apps/t2v/tests/test_cli.py
+++ b/apps/t2v/tests/test_cli.py
@@ -38,6 +38,7 @@
     BlitModelOutputToScreenLoop,
 )
 from flashdreams.runtime_v2.client_window_factory import ClientWindowMode
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -160,6 +161,9 @@ def __init__(self) -> None:
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        del request
+
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
 
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 50944d012..26542eb20 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -3,7 +3,7 @@
 
 """Client window abstract interface."""
 
-from abc import ABC
+from abc import ABC, abstractmethod
 
 from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 
@@ -49,15 +49,16 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         pass
 
-    # Optional to implement
+    @abstractmethod
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Request to open a file selector local to the client this window drives.
 
         The result arrives later through
         :meth:`InputSource.get_user_input_events` as
         :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
+        Every request must get a result; a window without a client file
+        selector reports ``UNAVAILABLE``.
 
         Args:
             request: Selector request queued by the UI loop.
         """
-        pass
diff --git a/flashdreams/test_v2/test_application_runner.py b/flashdreams/test_v2/test_application_runner.py
index 606c3899d..c6254c445 100644
--- a/flashdreams/test_v2/test_application_runner.py
+++ b/flashdreams/test_v2/test_application_runner.py
@@ -19,6 +19,7 @@
 from flashdreams.core.distributed.parallel import ParallelContext
 from flashdreams.runtime_v2.application_runner import ApplicationRunner
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import CloseUserInputEvent
@@ -146,6 +147,9 @@ def __init__(self, calls: list[str]) -> None:
         self.results: list[StepResult] = []
         self._reported_close = False
 
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        del request
+
     def get_user_input_events(self) -> UserInputEvents:
         if not self._reported_close:
             self._reported_close = True
diff --git a/flashdreams/test_v2/test_cli.py b/flashdreams/test_v2/test_cli.py
index 1c8731244..de6d3c4fb 100644
--- a/flashdreams/test_v2/test_cli.py
+++ b/flashdreams/test_v2/test_cli.py
@@ -22,6 +22,7 @@
 from flashdreams.runtime_v2.application_runner import ApplicationRunner, Unbound
 from flashdreams.runtime_v2.client_window_factory import ClientWindowMode
 from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
@@ -42,6 +43,9 @@ class _StubWindow(IClientWindow):
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        del request
+
     def open(self, session_desc: SessionDesc) -> None:
         del session_desc
 
diff --git a/flashdreams/test_v2/test_client_window.py b/flashdreams/test_v2/test_client_window.py
index 720ab4acc..974775508 100644
--- a/flashdreams/test_v2/test_client_window.py
+++ b/flashdreams/test_v2/test_client_window.py
@@ -11,6 +11,7 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.input_source import InputSource
 from flashdreams.api_v2.output_sink import OutputSink
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
@@ -36,6 +37,9 @@ def __init__(self) -> None:
     def get_user_input_events(self) -> UserInputEvents:
         return self._input
 
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        del request
+
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
         self._is_open = True
@@ -51,6 +55,24 @@ def update_input_events(self, input: UserInputEvents) -> None:
         self._input = input
 
 
+def test_client_window_must_answer_file_selection() -> None:
+    class NoFileSelection(IClientWindow):
+        def get_user_input_events(self) -> UserInputEvents:
+            return UserInputEvents([])
+
+        def open(self, session_desc: SessionDesc) -> None:
+            del session_desc
+
+        def write(self, result: StepResult) -> None:
+            del result
+
+        def close(self) -> None:
+            return
+
+    with pytest.raises(TypeError, match="request_selected_files"):
+        NoFileSelection()  # type: ignore[abstract]
+
+
 def test_client_window_for_null_model() -> None:
     # InputSource + OutputSink setup; the session layout desc arrives on open.
     client_window = FakeClientWindow()
diff --git a/integrations_v2/red_screen/red_screen/tests/test_red_screen.py b/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
index 4dafd5952..24369fc43 100644
--- a/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
+++ b/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
@@ -12,6 +12,7 @@
 
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.session import ISession
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -62,6 +63,9 @@ def get_user_input_events(self) -> UserInputEvents:
                 return self._batches.pop(0)
         return UserInputEvents([])
 
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        del request
+
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
         self._is_open = True
diff --git a/tests/test_step_agreement.py b/tests/test_step_agreement.py
index 794a0e246..ececdb88c 100644
--- a/tests/test_step_agreement.py
+++ b/tests/test_step_agreement.py
@@ -167,6 +167,9 @@ def _main_thread(self):
     def open(self, desc):
         self._main_thread()
 
+    def request_selected_files(self, request):
+        del request
+
     def get_user_input_events(self):
         self._main_thread()
         if (

From f40cac833d4db1a9c67d0d8c5349470a85b75d13 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 10:17:36 -0700
Subject: [PATCH 25/43] Add --disable-file-selection to turn off client file
 pickers for a run

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 docs/source/api/cli.rst                       |  4 ++++
 flashdreams/flashdreams/api_v2/README.md      |  3 ++-
 .../runtime_v2/client_window_factory.py       | 22 ++++++++++++++++--
 .../runtime_v2/native_window_client_window.py | 13 +++++++++++
 .../runtime_v2/webrtc_client_window.py        | 14 +++++++++++
 .../test_v2/test_client_window_factory.py     | 13 +++++++++++
 .../test_native_window_client_window.py       | 23 +++++++++++++++++++
 .../test_v2/test_webrtc_client_window.py      | 14 +++++++++++
 tools/package-as-offline-exe/README.md        |  3 +++
 9 files changed, 106 insertions(+), 3 deletions(-)

diff --git a/docs/source/api/cli.rst b/docs/source/api/cli.rst
index 86ccd62ff..2b8b01503 100644
--- a/docs/source/api/cli.rst
+++ b/docs/source/api/cli.rst
@@ -60,6 +60,10 @@ It defaults to warning; use ``FLASHDREAMS_PREPARATION_POLICY`` to select
 the FlashDreams cache, or ``FLASHDREAMS_PREPARATION_ISSUES_PATH`` when set.
 Add ``--skip-preload-validation`` to skip validation (running first-block of `ISession`).
 
+Add ``--disable-file-selection`` to a v2 run where the client has no usable file
+selector, such as a packaged app streamed from a remote host. Every file pick
+then reports ``UNAVAILABLE`` instead of opening a selector.
+
 The common command shape is ``flashdreams-run <runner> [mode]``. A runner only
 advertises modes it implements; unsupported pairs fail before CUDA
 initialization. Shared modes are ``run``, ``mp4``, ``null``, ``webrtc``, and
diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 1da196d79..e90c4ba20 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -235,7 +235,8 @@ different control (one id used twice in a tick raises `ValueError`). `accept` is
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
-`runtime_v2/selected_file.py`.
+`runtime_v2/selected_file.py`. A run launched with `--disable-file-selection`
+never opens a selector; every pick returns `UNAVAILABLE`, so handle that status.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/runtime_v2/client_window_factory.py b/flashdreams/flashdreams/runtime_v2/client_window_factory.py
index caedfb97a..058d7ff2f 100644
--- a/flashdreams/flashdreams/runtime_v2/client_window_factory.py
+++ b/flashdreams/flashdreams/runtime_v2/client_window_factory.py
@@ -49,6 +49,9 @@ def check_arguments(self, parsed_args: argparse.Namespace) -> None:
     def create(self, parsed_args: argparse.Namespace) -> IClientWindow:
         """Create the window.
 
+        When ``parsed_args.disable_file_selection`` is set, the window reports
+        every file pick as ``UNAVAILABLE`` without opening a selector.
+
         Raises:
             ValueError: Whatever :meth:`check_arguments` reports.
         """
@@ -116,7 +119,11 @@ def create(self, parsed_args: argparse.Namespace) -> IClientWindow:
         # Imported here so a run writing a file needs none of the serving stack.
         from flashdreams.runtime_v2.webrtc_client_window import WebRTCClientWindow
 
-        return WebRTCClientWindow(host=parsed_args.host, port=parsed_args.port)
+        return WebRTCClientWindow(
+            host=parsed_args.host,
+            port=parsed_args.port,
+            allow_file_selection=not parsed_args.disable_file_selection,
+        )
 
     def starting(self, client_window: IClientWindow) -> str | None:
         """Return where to connect, which nobody can guess when the port is free."""
@@ -142,7 +149,10 @@ def create(self, parsed_args: argparse.Namespace) -> IClientWindow:
             NativeWindowClientWindow,
         )
 
-        return NativeWindowClientWindow(title=parsed_args.window_title)
+        return NativeWindowClientWindow(
+            title=parsed_args.window_title,
+            allow_file_selection=not parsed_args.disable_file_selection,
+        )
 
 
 _BUILTIN_MODES: tuple[ClientWindowMode, ...] = (
@@ -253,6 +263,14 @@ def add_client_window_arguments(parser: argparse.ArgumentParser) -> None:
             "final session."
         ),
     )
+    parser.add_argument(
+        "--disable-file-selection",
+        action="store_true",
+        help=(
+            "Never open a client file selector; every file pick reports "
+            "unavailable. For packaged runs on platforms without one."
+        ),
+    )
     for mode in modes:
         mode.add_arguments(parser)
 
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 4ccacbd88..9dc131dfb 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -310,6 +310,7 @@ def __init__(
         self,
         *,
         title: str = "FlashDreams",
+        allow_file_selection: bool = True,
         presenter_factory: Callable[..., _SlangPyNativeWindowPresenter] | None = None,
         clock_ns: Callable[[], int] = time.monotonic_ns,
     ) -> None:
@@ -317,6 +318,8 @@ def __init__(
 
         Args:
             title: Native window title.
+            allow_file_selection: Whether file picks open the OS selector.
+                ``False`` reports every pick as ``UNAVAILABLE``.
             presenter_factory: Optional SlangPy-compatible presenter factory.
             clock_ns: Monotonic clock used for input timestamps.
 
@@ -326,6 +329,7 @@ def __init__(
         if not title.strip():
             raise ValueError("Native-window title must be non-empty.")
         self.title = title
+        self._allow_file_selection = allow_file_selection
         self._presenter_factory = presenter_factory
         self._clock_ns = clock_ns
         self._session_started_ns: int | None = None
@@ -382,6 +386,15 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the OS file selector and enqueue the chosen files."""
+        if not self._allow_file_selection:
+            self._put_input(
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=request.request_id,
+                    status=SelectedFilesStatus.UNAVAILABLE,
+                )
+            )
+            return
         started = self._file_gate.submit(
             replace(
                 QueuedFileSelection.from_request(request),
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index cddbd0def..45fd69533 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -53,6 +53,7 @@ def __init__(
         host: str = "127.0.0.1",
         port: int = 0,
         startup_timeout_seconds: float = 10.0,
+        allow_file_selection: bool = True,
     ) -> None:
         """Create the WebRTC backend.
 
@@ -63,7 +64,10 @@ def __init__(
             host: Interface on which the HTTP server listens.
             port: Listening port. Zero asks the operating system to choose one.
             startup_timeout_seconds: Maximum time to wait for server startup.
+            allow_file_selection: Whether file picks ask the browser.
+                ``False`` reports every pick as ``UNAVAILABLE``.
         """
+        self._allow_file_selection = allow_file_selection
         self._input_events: deque[UserInputEvent] = deque()
         self._hide_cursor = False
         self._lock_cursor_to_window = False
@@ -128,6 +132,16 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the connected browser to open a file selector."""
+        if not self._allow_file_selection:
+            with self._input_lock:
+                self._input_events.append(
+                    SelectedFilesUserInputEvent(
+                        timestamp=self.server.event_timestamp_us(),
+                        request_id=request.request_id,
+                        status=SelectedFilesStatus.UNAVAILABLE,
+                    )
+                )
+            return
         started = self._file_gate.submit(QueuedFileSelection.from_request(request))
         if started is not None:
             self._start_file_selection(started)
diff --git a/flashdreams/test_v2/test_client_window_factory.py b/flashdreams/test_v2/test_client_window_factory.py
index 129863e5d..cf315bbdc 100644
--- a/flashdreams/test_v2/test_client_window_factory.py
+++ b/flashdreams/test_v2/test_client_window_factory.py
@@ -123,6 +123,18 @@ def test_a_native_window_mode_is_lazy_and_keeps_its_title() -> None:
     assert window.title == "World model"
 
 
+def test_file_selection_is_allowed_unless_disabled() -> None:
+    allowed = create_client_window(_parsed(["--mode", "native-window"]))
+    disabled = create_client_window(
+        _parsed(["--mode", "native-window", "--disable-file-selection"])
+    )
+
+    assert isinstance(allowed, NativeWindowClientWindow)
+    assert isinstance(disabled, NativeWindowClientWindow)
+    assert allowed._allow_file_selection is True
+    assert disabled._allow_file_selection is False
+
+
 def test_an_installed_mode_owns_its_flashdreams_run_v2_arguments(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
@@ -290,6 +302,7 @@ def test_a_browser_run_is_told_where_to_connect(self) -> None:
         window = mode.create(_parsed(["--mode", "webrtc"]))
         try:
             assert isinstance(window, WebRTCClientWindow)
+            assert window._allow_file_selection is True
             assert window.metrics_snapshot()["webrtc_sender_queue_capacity_count"] == 2
             assert mode.starting(window) == f"Open {window.server.url} in a browser."
         finally:
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index c3749e63a..7ebfe9fc6 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -675,6 +675,29 @@ def test_native_window_reports_a_selected_file(
     assert event.files[0].data == b"png-bytes"
 
 
+def test_native_window_disabled_file_selection_reports_unavailable(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    def chooser(**_: object) -> tuple[str, ...]:
+        raise AssertionError("disabled file selection must not open a chooser")
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", chooser)
+    window = NativeWindowClientWindow(
+        allow_file_selection=False,
+        presenter_factory=_presenter_factory(_Presenter()),
+    )
+    window.open(_session_desc())
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.request_id == "open-1"
+    assert event.status is SelectedFilesStatus.UNAVAILABLE
+
+
 def test_native_window_reports_cancelled_file_selection(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 51c74690e..66c0c6779 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -599,6 +599,20 @@ async def test_browser_file_selector_result_reports_status() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_disabled_file_selection_reports_unavailable_without_browser() -> None:
+    window = WebRTCClientWindow(allow_file_selection=False)
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(_file_request("open-1"))
+        assert "open-1" not in window.server._pending_file_requests
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_browser_file_selector_result_cannot_claim_ok() -> None:
     window = WebRTCClientWindow()
diff --git a/tools/package-as-offline-exe/README.md b/tools/package-as-offline-exe/README.md
index 6946afa7c..4ae9a87b1 100644
--- a/tools/package-as-offline-exe/README.md
+++ b/tools/package-as-offline-exe/README.md
@@ -60,6 +60,9 @@ uv run python tools/package-as-offline-exe/package_as_offline_exe.py \
 Do not pass `--preload-application`; the packager controls preparation so it
 can validate and populate the bundle's caches.
 
+Pass `--disable-file-selection` to bake in a launcher that never opens a file
+selector; every file pick in the app then reports `UNAVAILABLE`.
+
 The generated launcher embeds the supplied application arguments to this installer program inside the executable.
 
 The packager runs initialization and one model block. Preparation findings are

From 14ccd518e3b1f401200893db6e0d1ef66c2f39cc Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 12:47:22 -0700
Subject: [PATCH 26/43] Drop test checks that only restate UI copy or dataclass
 fields

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/test_v2/test_selected_files.py       | 14 --------------
 flashdreams/test_v2/test_webrtc_client_window.py |  8 --------
 2 files changed, 22 deletions(-)

diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index c9a6ce0d4..563860207 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -62,20 +62,6 @@ def _ui_loop() -> _UILoop:
     return loop
 
 
-def test_selected_files_event_carries_bytes_and_request_id() -> None:
-    event = SelectedFilesUserInputEvent(
-        timestamp=uint64(1),
-        request_id="open-1",
-        status=SelectedFilesStatus.OK,
-        files=(SelectedFile(name="seed.png", data=b"png"),),
-    )
-
-    assert event.get_type_name() == "selected_files"
-    assert event.request_id == "open-1"
-    assert event.status is SelectedFilesStatus.OK
-    assert event.files[0].data == b"png"
-
-
 def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     loop = _ui_loop()
     loop.file_selector(
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 66c0c6779..f4a4d180e 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -662,10 +662,6 @@ async def test_browser_script_checks_type_and_size_before_upload() -> None:
     window = WebRTCClientWindow()
     try:
         async with ClientSession() as client:
-            async with client.get(window.server.url) as response:
-                page = await response.text()
-                assert 'id="prompt-dialog"' in page
-                assert "Choose file" not in page
             async with client.get(f"{window.server.url}app.js") as response:
                 script = await response.text()
         assert "fileNameMatchesAccept" in script
@@ -676,10 +672,6 @@ async def test_browser_script_checks_type_and_size_before_upload() -> None:
             "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`" in script
         )
         assert "input.multiple" in script
-        assert "showModal" not in script
-        assert "The app requested a file" in script
-        assert "The app requested files" in script
-        assert 'completeFileSelection(pendingFileRequest.id, "cancelled")' not in script
     finally:
         window.close()
 

From 0a2f8fd677009185cd79a1144a2ddb14a0fcbbf5 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 14:53:53 -0700
Subject: [PATCH 27/43] Remove --disable-file-selection; the host decides
 whether a picker works

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 docs/source/documentation/cli.md              |  4 ----
 flashdreams/flashdreams/api_v2/README.md      |  3 +--
 .../runtime_v2/client_window_factory.py       | 22 ++----------------
 .../runtime_v2/native_window_client_window.py | 13 -----------
 .../runtime_v2/webrtc_client_window.py        | 14 -----------
 .../test_v2/test_client_window_factory.py     | 13 -----------
 .../test_native_window_client_window.py       | 23 -------------------
 .../test_v2/test_webrtc_client_window.py      | 14 -----------
 tools/package-as-offline-exe/README.md        |  3 ---
 9 files changed, 3 insertions(+), 106 deletions(-)

diff --git a/docs/source/documentation/cli.md b/docs/source/documentation/cli.md
index a8daa6e84..00515332c 100644
--- a/docs/source/documentation/cli.md
+++ b/docs/source/documentation/cli.md
@@ -101,10 +101,6 @@ are written to `preparation_issues.txt` in the FlashDreams cache, or to
 `FLASHDREAMS_PREPARATION_ISSUES_PATH` when set. Use
 `--skip-preload-validation` to skip the first-block validation.
 
-Add `--disable-file-selection` to a v2 run where the client has no usable file
-selector, such as a packaged app streamed from a remote host. Every file pick
-then reports `UNAVAILABLE` instead of opening a selector.
-
 Open a local native window:
 
 ```bash
diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index e90c4ba20..1da196d79 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -235,8 +235,7 @@ different control (one id used twice in a tick raises `ValueError`). `accept` is
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
-`runtime_v2/selected_file.py`. A run launched with `--disable-file-selection`
-never opens a selector; every pick returns `UNAVAILABLE`, so handle that status.
+`runtime_v2/selected_file.py`.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/runtime_v2/client_window_factory.py b/flashdreams/flashdreams/runtime_v2/client_window_factory.py
index 058d7ff2f..caedfb97a 100644
--- a/flashdreams/flashdreams/runtime_v2/client_window_factory.py
+++ b/flashdreams/flashdreams/runtime_v2/client_window_factory.py
@@ -49,9 +49,6 @@ def check_arguments(self, parsed_args: argparse.Namespace) -> None:
     def create(self, parsed_args: argparse.Namespace) -> IClientWindow:
         """Create the window.
 
-        When ``parsed_args.disable_file_selection`` is set, the window reports
-        every file pick as ``UNAVAILABLE`` without opening a selector.
-
         Raises:
             ValueError: Whatever :meth:`check_arguments` reports.
         """
@@ -119,11 +116,7 @@ def create(self, parsed_args: argparse.Namespace) -> IClientWindow:
         # Imported here so a run writing a file needs none of the serving stack.
         from flashdreams.runtime_v2.webrtc_client_window import WebRTCClientWindow
 
-        return WebRTCClientWindow(
-            host=parsed_args.host,
-            port=parsed_args.port,
-            allow_file_selection=not parsed_args.disable_file_selection,
-        )
+        return WebRTCClientWindow(host=parsed_args.host, port=parsed_args.port)
 
     def starting(self, client_window: IClientWindow) -> str | None:
         """Return where to connect, which nobody can guess when the port is free."""
@@ -149,10 +142,7 @@ def create(self, parsed_args: argparse.Namespace) -> IClientWindow:
             NativeWindowClientWindow,
         )
 
-        return NativeWindowClientWindow(
-            title=parsed_args.window_title,
-            allow_file_selection=not parsed_args.disable_file_selection,
-        )
+        return NativeWindowClientWindow(title=parsed_args.window_title)
 
 
 _BUILTIN_MODES: tuple[ClientWindowMode, ...] = (
@@ -263,14 +253,6 @@ def add_client_window_arguments(parser: argparse.ArgumentParser) -> None:
             "final session."
         ),
     )
-    parser.add_argument(
-        "--disable-file-selection",
-        action="store_true",
-        help=(
-            "Never open a client file selector; every file pick reports "
-            "unavailable. For packaged runs on platforms without one."
-        ),
-    )
     for mode in modes:
         mode.add_arguments(parser)
 
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 9dc131dfb..4ccacbd88 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -310,7 +310,6 @@ def __init__(
         self,
         *,
         title: str = "FlashDreams",
-        allow_file_selection: bool = True,
         presenter_factory: Callable[..., _SlangPyNativeWindowPresenter] | None = None,
         clock_ns: Callable[[], int] = time.monotonic_ns,
     ) -> None:
@@ -318,8 +317,6 @@ def __init__(
 
         Args:
             title: Native window title.
-            allow_file_selection: Whether file picks open the OS selector.
-                ``False`` reports every pick as ``UNAVAILABLE``.
             presenter_factory: Optional SlangPy-compatible presenter factory.
             clock_ns: Monotonic clock used for input timestamps.
 
@@ -329,7 +326,6 @@ def __init__(
         if not title.strip():
             raise ValueError("Native-window title must be non-empty.")
         self.title = title
-        self._allow_file_selection = allow_file_selection
         self._presenter_factory = presenter_factory
         self._clock_ns = clock_ns
         self._session_started_ns: int | None = None
@@ -386,15 +382,6 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the OS file selector and enqueue the chosen files."""
-        if not self._allow_file_selection:
-            self._put_input(
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id=request.request_id,
-                    status=SelectedFilesStatus.UNAVAILABLE,
-                )
-            )
-            return
         started = self._file_gate.submit(
             replace(
                 QueuedFileSelection.from_request(request),
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 45fd69533..cddbd0def 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -53,7 +53,6 @@ def __init__(
         host: str = "127.0.0.1",
         port: int = 0,
         startup_timeout_seconds: float = 10.0,
-        allow_file_selection: bool = True,
     ) -> None:
         """Create the WebRTC backend.
 
@@ -64,10 +63,7 @@ def __init__(
             host: Interface on which the HTTP server listens.
             port: Listening port. Zero asks the operating system to choose one.
             startup_timeout_seconds: Maximum time to wait for server startup.
-            allow_file_selection: Whether file picks ask the browser.
-                ``False`` reports every pick as ``UNAVAILABLE``.
         """
-        self._allow_file_selection = allow_file_selection
         self._input_events: deque[UserInputEvent] = deque()
         self._hide_cursor = False
         self._lock_cursor_to_window = False
@@ -132,16 +128,6 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the connected browser to open a file selector."""
-        if not self._allow_file_selection:
-            with self._input_lock:
-                self._input_events.append(
-                    SelectedFilesUserInputEvent(
-                        timestamp=self.server.event_timestamp_us(),
-                        request_id=request.request_id,
-                        status=SelectedFilesStatus.UNAVAILABLE,
-                    )
-                )
-            return
         started = self._file_gate.submit(QueuedFileSelection.from_request(request))
         if started is not None:
             self._start_file_selection(started)
diff --git a/flashdreams/test_v2/test_client_window_factory.py b/flashdreams/test_v2/test_client_window_factory.py
index cf315bbdc..129863e5d 100644
--- a/flashdreams/test_v2/test_client_window_factory.py
+++ b/flashdreams/test_v2/test_client_window_factory.py
@@ -123,18 +123,6 @@ def test_a_native_window_mode_is_lazy_and_keeps_its_title() -> None:
     assert window.title == "World model"
 
 
-def test_file_selection_is_allowed_unless_disabled() -> None:
-    allowed = create_client_window(_parsed(["--mode", "native-window"]))
-    disabled = create_client_window(
-        _parsed(["--mode", "native-window", "--disable-file-selection"])
-    )
-
-    assert isinstance(allowed, NativeWindowClientWindow)
-    assert isinstance(disabled, NativeWindowClientWindow)
-    assert allowed._allow_file_selection is True
-    assert disabled._allow_file_selection is False
-
-
 def test_an_installed_mode_owns_its_flashdreams_run_v2_arguments(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
@@ -302,7 +290,6 @@ def test_a_browser_run_is_told_where_to_connect(self) -> None:
         window = mode.create(_parsed(["--mode", "webrtc"]))
         try:
             assert isinstance(window, WebRTCClientWindow)
-            assert window._allow_file_selection is True
             assert window.metrics_snapshot()["webrtc_sender_queue_capacity_count"] == 2
             assert mode.starting(window) == f"Open {window.server.url} in a browser."
         finally:
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 7ebfe9fc6..c3749e63a 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -675,29 +675,6 @@ def test_native_window_reports_a_selected_file(
     assert event.files[0].data == b"png-bytes"
 
 
-def test_native_window_disabled_file_selection_reports_unavailable(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    def chooser(**_: object) -> tuple[str, ...]:
-        raise AssertionError("disabled file selection must not open a chooser")
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", chooser)
-    window = NativeWindowClientWindow(
-        allow_file_selection=False,
-        presenter_factory=_presenter_factory(_Presenter()),
-    )
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    events = _wait_for_input_events(window)
-    window.close()
-
-    assert len(events) == 1
-    event = events[0]
-    assert isinstance(event, SelectedFilesUserInputEvent)
-    assert event.request_id == "open-1"
-    assert event.status is SelectedFilesStatus.UNAVAILABLE
-
-
 def test_native_window_reports_cancelled_file_selection(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index f4a4d180e..df545a610 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -599,20 +599,6 @@ async def test_browser_file_selector_result_reports_status() -> None:
         window.close()
 
 
-@pytest.mark.asyncio
-async def test_disabled_file_selection_reports_unavailable_without_browser() -> None:
-    window = WebRTCClientWindow(allow_file_selection=False)
-    window.open(_session_desc())
-    try:
-        window.request_selected_files(_file_request("open-1"))
-        assert "open-1" not in window.server._pending_file_requests
-        event = await _wait_selected_files_event(window)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.UNAVAILABLE
-    finally:
-        window.close()
-
-
 @pytest.mark.asyncio
 async def test_browser_file_selector_result_cannot_claim_ok() -> None:
     window = WebRTCClientWindow()
diff --git a/tools/package-as-offline-exe/README.md b/tools/package-as-offline-exe/README.md
index 4ae9a87b1..6946afa7c 100644
--- a/tools/package-as-offline-exe/README.md
+++ b/tools/package-as-offline-exe/README.md
@@ -60,9 +60,6 @@ uv run python tools/package-as-offline-exe/package_as_offline_exe.py \
 Do not pass `--preload-application`; the packager controls preparation so it
 can validate and populate the bundle's caches.
 
-Pass `--disable-file-selection` to bake in a launcher that never opens a file
-selector; every file pick in the app then reports `UNAVAILABLE`.
-
 The generated launcher embeds the supplied application arguments to this installer program inside the executable.
 
 The packager runs initialization and one model block. Preparation findings are

From 320b68f1cc7b18f89e5d54e3ca36969caa39aea9 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 15:02:57 -0700
Subject: [PATCH 28/43] Default IClientWindow.request_selected_files to an
 immediate UNAVAILABLE result

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 apps/action2v/tests/test_application.py       |  4 --
 apps/t2v/t2v/testing.py                       | 21 +++++++-
 apps/t2v/tests/test_cli.py                    |  4 --
 .../flashdreams/api_v2/client_window.py       | 33 ++++++++----
 flashdreams/flashdreams/api_v2/loop.py        | 16 ++++--
 .../runtime_v2/mp4_client_window.py           | 48 ++---------------
 .../runtime_v2/null_client_window.py          | 53 ++-----------------
 .../flashdreams/runtime_v2/session_runner.py  | 16 ++++--
 .../test_v2/test_application_runner.py        |  4 --
 flashdreams/test_v2/test_cli.py               |  4 --
 flashdreams/test_v2/test_client_window.py     | 22 --------
 flashdreams/test_v2/test_selected_files.py    | 22 +++-----
 flashdreams/test_v2/test_session_runner.py    | 35 ++++++++++--
 .../red_screen/tests/test_red_screen.py       |  4 --
 tests/test_step_agreement.py                  |  3 --
 15 files changed, 111 insertions(+), 178 deletions(-)

diff --git a/apps/action2v/tests/test_application.py b/apps/action2v/tests/test_application.py
index d5ab5f410..c767d5950 100644
--- a/apps/action2v/tests/test_application.py
+++ b/apps/action2v/tests/test_application.py
@@ -22,7 +22,6 @@
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.session_runner import run_session
 from flashdreams.runtime_v2.step_result import StepResult
@@ -143,9 +142,6 @@ def open(self, session_desc: SessionDesc) -> None:
         del session_desc
         self.opened = True
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        del request
-
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         assert self.opened
         self.cursor_requests.append(("hide", hide_cursor))
diff --git a/apps/t2v/t2v/testing.py b/apps/t2v/t2v/testing.py
index 548e68a01..648639a68 100644
--- a/apps/t2v/t2v/testing.py
+++ b/apps/t2v/t2v/testing.py
@@ -20,12 +20,12 @@
 import numpy.typing as npt
 import torch
 
+from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.runtime_v2.blit_model_output_to_screen_loop import (
     BlitModelOutputToScreenLoop,
 )
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
-from flashdreams.runtime_v2.null_client_window import NullClientWindow
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -33,6 +33,7 @@
 )
 from flashdreams.runtime_v2.session_runner import run_session
 from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
 from t2v.application import T2VApplication
 from t2v.ui import T2VImGuiUILoop
@@ -168,7 +169,7 @@ def check_t2v_model_impl(
         ):
             run_session(
                 application.create_session(session_desc),
-                NullClientWindow(),
+                _DiscardingClientWindow(),
                 metrics_output_sink=inspector,
                 steps=steps,
             )
@@ -403,6 +404,22 @@ def close(self) -> None:
             self._mp4.close()
 
 
+class _DiscardingClientWindow(IClientWindow):
+    """Drive a checked run without retaining its composed UI output."""
+
+    def get_user_input_events(self) -> UserInputEvents:
+        return UserInputEvents([])
+
+    def open(self, session_desc: SessionDesc) -> None:
+        del session_desc
+
+    def write(self, result: StepResult) -> None:
+        del result
+
+    def close(self) -> None:
+        return
+
+
 def _compare(
     inspector: _FrameInspector,
     expected: ExpectedFrameStats,
diff --git a/apps/t2v/tests/test_cli.py b/apps/t2v/tests/test_cli.py
index 48de638c9..144217b65 100644
--- a/apps/t2v/tests/test_cli.py
+++ b/apps/t2v/tests/test_cli.py
@@ -38,7 +38,6 @@
     BlitModelOutputToScreenLoop,
 )
 from flashdreams.runtime_v2.client_window_factory import ClientWindowMode
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -161,9 +160,6 @@ def __init__(self) -> None:
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        del request
-
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
 
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 26542eb20..1bcfee1dc 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -3,9 +3,15 @@
 
 """Client window abstract interface."""
 
-from abc import ABC, abstractmethod
+from abc import ABC
 
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
+from numpy import uint64
+
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
+from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 
 from .input_source import InputSource
 from .output_sink import OutputSink
@@ -49,16 +55,25 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         pass
 
-    @abstractmethod
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
+    # Optional to implement
+    def request_selected_files(
+        self, request: FileSelectionRequest
+    ) -> SelectedFilesUserInputEvent | None:
         """Request to open a file selector local to the client this window drives.
 
-        The result arrives later through
-        :meth:`InputSource.get_user_input_events` as
-        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`.
-        Every request must get a result; a window without a client file
-        selector reports ``UNAVAILABLE``.
+        Every request gets exactly one result. Return it now, or return
+        ``None`` and deliver it later through
+        :meth:`InputSource.get_user_input_events`. The default has no
+        selector and returns ``UNAVAILABLE``.
 
         Args:
             request: Selector request queued by the UI loop.
+
+        Returns:
+            The result when it is known immediately, otherwise ``None``.
         """
+        return SelectedFilesUserInputEvent(
+            timestamp=uint64(0),
+            request_id=request.request_id,
+            status=SelectedFilesStatus.UNAVAILABLE,
+        )
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 4f5482cf5..086bea6a0 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -547,10 +547,18 @@ def file_selector(
     ) -> SelectedFilesUserInputEvent | None:
         """Drive one client file-selector control and return this tick's result.
 
-        Call every UI tick for each control. Pass ``open=True`` only when
-        that control was activated this tick. ``request_id`` is which
-        control this is: reuse it so extra clicks do not stack pickers;
-        use a different id for a different control.
+        Call every UI tick for each control, like an ImGui widget. Pass
+        ``open=True`` on the tick the control is activated. Give each control
+        its own stable ``request_id``. While a pick for ``request_id`` is
+        still open, another ``open=True`` for it is dropped with a warning.
+
+        Example:
+
+        .. code-block:: python
+
+            pick = self.file_selector("open-image", open=imgui.button("Open"))
+            if pick is not None and pick.status is SelectedFilesStatus.OK:
+                image_bytes = pick.files[0].data
 
         Args:
             request_id: Stable id for this control. Echoed on the matching event.
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index c59a08445..3e2c72ac6 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -5,36 +5,19 @@
 
 from pathlib import Path
 
-from numpy import uint64
-
 from flashdreams.api_v2.client_window import IClientWindow
-from flashdreams.runtime_v2.file_selection_gate import (
-    FileSelectionGate,
-    QueuedFileSelection,
-)
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
-from flashdreams.runtime_v2.selected_file import (
-    FileSelectionRequest,
-    SelectedFilesStatus,
-)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import (
-    SelectedFilesUserInputEvent,
-    UserInputEvent,
-)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
 class Mp4ClientWindow(IClientWindow):
-    """Write UI frames to an MP4 file.
+    """Write UI frames to an MP4 file and report no input.
 
     The session must finish on its own because this window never sends a close
     event. Use ``BackpressureMode.BLOCK`` with
     ``PresentationMode.ON_DEMAND`` to write every frame once.
-
-    File-selector requests complete immediately as unavailable. This window
-    writes the run to a file; it has no interactive client.
     """
 
     def __init__(self, path: str | Path) -> None:
@@ -44,8 +27,6 @@ def __init__(self, path: str | Path) -> None:
         """
         self._path = Path(path)
         self._video_sink = Mp4OutputSink(path)
-        self._pending_events: list[UserInputEvent] = []
-        self._file_gate = FileSelectionGate()
 
     @property
     def path(self) -> Path:
@@ -53,28 +34,8 @@ def path(self) -> Path:
         return self._path
 
     def get_user_input_events(self) -> UserInputEvents:
-        """Return file-selector results queued since the previous poll."""
-        events = self._pending_events
-        self._pending_events = []
-        return UserInputEvents(events)
-
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        """Complete a file-selector request as unavailable."""
-        started = self._file_gate.submit(QueuedFileSelection.from_request(request))
-        while started is not None:
-            claimed, nxt = self._file_gate.complete(
-                started.request_id, started.generation
-            )
-            if claimed:
-                self._pending_events.append(
-                    SelectedFilesUserInputEvent(
-                        timestamp=uint64(0),
-                        request_id=started.request_id,
-                        status=SelectedFilesStatus.UNAVAILABLE,
-                        _generation=started.generation,
-                    )
-                )
-            started = nxt
+        """Return an empty input batch."""
+        return UserInputEvents([])
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the MP4 presentation dimensions without replacing the session.
@@ -91,8 +52,6 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def open(self, session_desc: SessionDesc) -> None:
         """Prepare to write a session's output."""
-        self._file_gate.clear()
-        self._pending_events.clear()
         self._video_sink.open(session_desc)
 
     def write(self, result: StepResult) -> None:
@@ -102,4 +61,3 @@ def write(self, result: StepResult) -> None:
     def close(self) -> None:
         """Finish the MP4 file."""
         self._video_sink.close()
-        self._file_gate.clear()
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index 96056307f..76ff107fa 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -3,67 +3,22 @@
 
 """Client window that discards output and reports no input."""
 
-from numpy import uint64
-
 from flashdreams.api_v2.client_window import IClientWindow
-from flashdreams.runtime_v2.file_selection_gate import (
-    FileSelectionGate,
-    QueuedFileSelection,
-)
-from flashdreams.runtime_v2.selected_file import (
-    FileSelectionRequest,
-    SelectedFilesStatus,
-)
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import (
-    SelectedFilesUserInputEvent,
-    UserInputEvent,
-)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
 class NullClientWindow(IClientWindow):
-    """Discard output and report no input.
-
-    File-selector requests complete immediately as unavailable. This window
-    has no interactive client.
-    """
-
-    def __init__(self) -> None:
-        """Create a window that drops output."""
-        self._pending_events: list[UserInputEvent] = []
-        self._file_gate = FileSelectionGate()
+    """Discard output and report no input."""
 
     def get_user_input_events(self) -> UserInputEvents:
-        """Return file-selector results queued since the previous poll."""
-        events = self._pending_events
-        self._pending_events = []
-        return UserInputEvents(events)
-
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        """Complete a file-selector request as unavailable."""
-        started = self._file_gate.submit(QueuedFileSelection.from_request(request))
-        while started is not None:
-            claimed, nxt = self._file_gate.complete(
-                started.request_id, started.generation
-            )
-            if claimed:
-                self._pending_events.append(
-                    SelectedFilesUserInputEvent(
-                        timestamp=uint64(0),
-                        request_id=started.request_id,
-                        status=SelectedFilesStatus.UNAVAILABLE,
-                        _generation=started.generation,
-                    )
-                )
-            started = nxt
+        """Return an empty input batch."""
+        return UserInputEvents([])
 
     def open(self, session_desc: SessionDesc) -> None:
         """Accept a session without opening an output."""
         del session_desc
-        self._file_gate.clear()
-        self._pending_events.clear()
 
     def write(self, result: StepResult) -> None:
         """Discard one result."""
@@ -71,4 +26,4 @@ def write(self, result: StepResult) -> None:
 
     def close(self) -> None:
         """Close without releasing any resources."""
-        self._file_gate.clear()
+        return
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 3f02a5602..8cd2bc871 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -19,11 +19,13 @@
     UILoopRequests,
 )
 from flashdreams.api_v2.session import ISession
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.coordination import StepAgreement
 from flashdreams.runtime_v2.event_buffer import EventBuffer
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 _LOGGER = logging.getLogger(__name__)
 _MODEL_THREAD_NAME = "flashdreams-model-generation-thread"
@@ -175,7 +177,9 @@ def run_ui_once(*, step_requested: bool = True) -> None:
 
                 request = ui_loop.flush_ui_loop_requests()
                 if request is not None:
-                    _apply_window_requests(window, request)
+                    immediate = _apply_window_requests(window, request)
+                    if immediate:
+                        event_buffer.append(UserInputEvents(immediate))
                     if request.new_session is not None:
                         next_session_desc = request.new_session
                         stop.set()
@@ -405,16 +409,18 @@ def should_end_ui() -> bool:
     return next_session_desc
 
 
-def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> None:
-    """Apply UI window settings in request order."""
+def _apply_window_requests(
+    window: IClientWindow, request: UILoopRequests
+) -> list[UserInputEvent]:
+    """Apply UI window settings in request order; return immediate file results."""
     if request.hide_cursor is not None:
         window.request_hide_cursor(request.hide_cursor)
     if request.lock_cursor_to_window is not None:
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
-    for selection in request.file_selections:
-        window.request_selected_files(selection)
+    results = (window.request_selected_files(item) for item in request.file_selections)
+    return [result for result in results if result is not None]
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/test_v2/test_application_runner.py b/flashdreams/test_v2/test_application_runner.py
index c6254c445..606c3899d 100644
--- a/flashdreams/test_v2/test_application_runner.py
+++ b/flashdreams/test_v2/test_application_runner.py
@@ -19,7 +19,6 @@
 from flashdreams.core.distributed.parallel import ParallelContext
 from flashdreams.runtime_v2.application_runner import ApplicationRunner
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import CloseUserInputEvent
@@ -147,9 +146,6 @@ def __init__(self, calls: list[str]) -> None:
         self.results: list[StepResult] = []
         self._reported_close = False
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        del request
-
     def get_user_input_events(self) -> UserInputEvents:
         if not self._reported_close:
             self._reported_close = True
diff --git a/flashdreams/test_v2/test_cli.py b/flashdreams/test_v2/test_cli.py
index de6d3c4fb..1c8731244 100644
--- a/flashdreams/test_v2/test_cli.py
+++ b/flashdreams/test_v2/test_cli.py
@@ -22,7 +22,6 @@
 from flashdreams.runtime_v2.application_runner import ApplicationRunner, Unbound
 from flashdreams.runtime_v2.client_window_factory import ClientWindowMode
 from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
@@ -43,9 +42,6 @@ class _StubWindow(IClientWindow):
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        del request
-
     def open(self, session_desc: SessionDesc) -> None:
         del session_desc
 
diff --git a/flashdreams/test_v2/test_client_window.py b/flashdreams/test_v2/test_client_window.py
index 974775508..720ab4acc 100644
--- a/flashdreams/test_v2/test_client_window.py
+++ b/flashdreams/test_v2/test_client_window.py
@@ -11,7 +11,6 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.input_source import InputSource
 from flashdreams.api_v2.output_sink import OutputSink
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
@@ -37,9 +36,6 @@ def __init__(self) -> None:
     def get_user_input_events(self) -> UserInputEvents:
         return self._input
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        del request
-
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
         self._is_open = True
@@ -55,24 +51,6 @@ def update_input_events(self, input: UserInputEvents) -> None:
         self._input = input
 
 
-def test_client_window_must_answer_file_selection() -> None:
-    class NoFileSelection(IClientWindow):
-        def get_user_input_events(self) -> UserInputEvents:
-            return UserInputEvents([])
-
-        def open(self, session_desc: SessionDesc) -> None:
-            del session_desc
-
-        def write(self, result: StepResult) -> None:
-            del result
-
-        def close(self) -> None:
-            return
-
-    with pytest.raises(TypeError, match="request_selected_files"):
-        NoFileSelection()  # type: ignore[abstract]
-
-
 def test_client_window_for_null_model() -> None:
     # InputSource + OutputSink setup; the session layout desc arrives on open.
     client_window = FakeClientWindow()
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 563860207..b25674ade 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -308,27 +308,17 @@ def test_selected_files_event_rejects_inconsistent_status() -> None:
 
 
 @pytest.mark.parametrize("kind", ["mp4", "null"])
-def test_headless_window_completes_queued_file_selections_as_unavailable(
+def test_window_without_a_selector_answers_unavailable(
     kind: str, tmp_path: Path
 ) -> None:
     window = (
         Mp4ClientWindow(tmp_path / "clip.mp4") if kind == "mp4" else NullClientWindow()
     )
-    window.request_selected_files(
+    pick = window.request_selected_files(
         FileSelectionRequest(request_id="open-1", initial_path="/tmp")
     )
-    window.request_selected_files(
-        FileSelectionRequest(request_id="open-2", initial_path="/var")
-    )
-
-    events = window.get_user_input_events().get_events()
 
-    picks = [
-        event for event in events if isinstance(event, SelectedFilesUserInputEvent)
-    ]
-    assert [event.request_id for event in picks] == ["open-1", "open-2"]
-    assert all(
-        event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
-        for event in picks
-    )
-    assert window.get_user_input_events().get_events() == []
+    assert pick is not None
+    assert pick.request_id == "open-1"
+    assert pick.status is SelectedFilesStatus.UNAVAILABLE
+    assert pick.files == ()
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index 3b3ff3297..103ea2b30 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -35,7 +35,10 @@
     PresentationManager,
     _PresentationClock,
 )
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
+from flashdreams.runtime_v2.selected_file import (
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -48,6 +51,7 @@
     KeyboardInputState,
     KeyboardUserInputEvent,
     ResetUserInputEvent,
+    SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_tensor import VideoTensorLayout
@@ -676,10 +680,13 @@ def request_lock_cursor_to_window(self, lock_cursor_to_window: bool) -> None:
         self._log.record("window.request_lock_cursor_to_window")
         self.cursor_requests.append(("lock", lock_cursor_to_window))
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        """Record one file-selector request."""
+    def request_selected_files(
+        self, request: FileSelectionRequest
+    ) -> SelectedFilesUserInputEvent | None:
+        """Record one file-selector request and answer with the default."""
         self._log.record("window.request_selected_files")
         self.file_selection_requests.append(request)
+        return super().request_selected_files(request)
 
     def get_user_input_events(self) -> UserInputEvents:
         self._log.record("window.get_user_input_events")
@@ -1409,6 +1416,28 @@ def open_selector(_: object) -> None:
     assert "window.request_selected_files" in log.calls
 
 
+def test_run_session_delivers_an_immediate_file_selection_result() -> None:
+    log = CallLog()
+    picks: list[SelectedFilesUserInputEvent] = []
+
+    class PickingSession(FakeSession):
+        def run_ui(self, step_index: int, events: UserInputEvents) -> list[StepResult]:
+            pick = self.ui_loop.file_selector("open-1", open=self.ui_steps == 0)
+            self.ui_steps += 1
+            if pick is not None:
+                picks.append(pick)
+            return super().run_ui(step_index, events)
+
+    session_desc = replace(
+        _session_desc(), presentation_mode=PresentationMode.CONTINUOUS
+    )
+    run_session(PickingSession(session_desc, log), RecordingClientWindow(log), steps=4)
+
+    assert [(pick.request_id, pick.status) for pick in picks] == [
+        ("open-1", SelectedFilesStatus.UNAVAILABLE)
+    ]
+
+
 def test_timeout_wins_over_a_ui_requested_replacement() -> None:
     log = CallLog()
     resolved = _session_desc()
diff --git a/integrations_v2/red_screen/red_screen/tests/test_red_screen.py b/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
index 24369fc43..4dafd5952 100644
--- a/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
+++ b/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
@@ -12,7 +12,6 @@
 
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.session import ISession
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -63,9 +62,6 @@ def get_user_input_events(self) -> UserInputEvents:
                 return self._batches.pop(0)
         return UserInputEvents([])
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        del request
-
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
         self._is_open = True
diff --git a/tests/test_step_agreement.py b/tests/test_step_agreement.py
index ececdb88c..794a0e246 100644
--- a/tests/test_step_agreement.py
+++ b/tests/test_step_agreement.py
@@ -167,9 +167,6 @@ def _main_thread(self):
     def open(self, desc):
         self._main_thread()
 
-    def request_selected_files(self, request):
-        del request
-
     def get_user_input_events(self):
         self._main_thread()
         if (

From d9f201b0593e2bdbccece443a085761f55560a00 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 15:11:17 -0700
Subject: [PATCH 29/43] Clarify file selector request IDs in documentation

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md   | 12 ++++++------
 flashdreams/flashdreams/api_v2/loop.py     | 14 ++++++++------
 flashdreams/test_v2/test_selected_files.py |  2 +-
 integrations_v2/imgui_ui_demo/README.md    |  4 ++--
 4 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 1da196d79..f89205988 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -224,14 +224,14 @@ UI control that needs a fresh application session calls
 `request_new_session(session_desc)` with a fully resolved replacement
 description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. Remaining timeout and remaining model steps
-still apply to the replacement. A control that needs a file from the client
-calls `file_selector` every UI tick with a stable `request_id`.
-Pass `open=True` only when that control was activated this tick (for ImGui,
+still apply to the replacement. Call `file_selector` every UI tick from each
+place in the UI that can open a client file picker, using a stable `request_id`.
+Pass `open=True` only when the user asks to open it on that tick (for ImGui,
 `open=imgui.button(...)`). The call returns this tick's
 `SelectedFilesUserInputEvent` for that id, or `None`. Read `status`; use
-`files` only when the pick succeeded. Reuse the same `request_id` for the
-same control so extra clicks do not stack pickers; use a different id for a
-different control (one id used twice in a tick raises `ValueError`). `accept` is filename suffixes (empty = any type);
+`files` only when the pick succeeded. Reuse that `request_id` so extra clicks
+do not stack pickers; use a different id for every other place that can open
+one. Using an id twice in one tick raises `ValueError`. `accept` is filename suffixes (empty = any type);
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 086bea6a0..de7511402 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -545,11 +545,12 @@ def file_selector(
         max_file_bytes: int | None = None,
         multiple: bool = False,
     ) -> SelectedFilesUserInputEvent | None:
-        """Drive one client file-selector control and return this tick's result.
+        """Request files from the client and return this tick's matching result.
 
-        Call every UI tick for each control, like an ImGui widget. Pass
-        ``open=True`` on the tick the control is activated. Give each control
-        its own stable ``request_id``. While a pick for ``request_id`` is
+        Call every UI tick from each place in the UI that can open a picker.
+        Pass ``open=True`` only on the tick that the user asks to open it, such
+        as when an ImGui button returns ``True``. Use a different stable
+        ``request_id`` for each such place. While a pick for ``request_id`` is
         still open, another ``open=True`` for it is dropped with a warning.
 
         Example:
@@ -561,7 +562,8 @@ def file_selector(
                 image_bytes = pick.files[0].data
 
         Args:
-            request_id: Stable id for this control. Echoed on the matching event.
+            request_id: Stable id for this place in the UI. Echoed on the
+                matching event.
             initial_path: Directory hint for the selector; ``None`` uses the
                 current user's home directory.
             open: Whether to start a selector this tick.
@@ -593,7 +595,7 @@ def file_selector(
             raise TypeError("open must be a bool.")
         if request_id in self._file_selector_ids:
             raise ValueError(
-                f"request_id {request_id!r} is used by more than one control."
+                f"request_id {request_id!r} is used more than once this tick."
             )
         if open:
             if initial_path is None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index b25674ade..b53e2f40e 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -87,7 +87,7 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
 def test_ui_loop_rejects_request_id_reused_in_one_tick() -> None:
     loop = _ui_loop()
     loop.file_selector("open-1")
-    with pytest.raises(ValueError, match="more than one control"):
+    with pytest.raises(ValueError, match="more than once this tick"):
         loop.file_selector("open-1", open=True)
 
     loop.flush_ui_loop_requests()
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index e11aefa35..dd20c5bea 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -9,9 +9,9 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
 
 - `imgui-ui-text-input` renders an editable text field over model output.
 - `imgui-ui-file-picker` opens the client file selector and shows the chosen
-  name and size. Each Open control calls `file_selector` every UI tick with
+  name and size. Each Open button calls `file_selector` every UI tick with
   a stable `request_id`; the returned event carries the file bytes. Extra
-  clicks on the same control while a picker is open are ignored;
+  clicks on the same button while a picker is open are ignored;
   **Open A then B** queues both selectors one at a time. Closing the native
   window or dropping the WebRTC tab completes leftover and in-flight picks
   as unavailable.

From 864a51ff410b1ac28430563617dd3a28c2f891ee Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Mon, 12 Oct 2026 17:09:46 -0700
Subject: [PATCH 30/43] Time out file pickers the host never shows

Answer UNAVAILABLE when the host does not present a picker within 300 seconds. Once a picker is presented there is no deadline, so the user may keep it open as long as they want. The WebRTC page acknowledges when its prompt is shown.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |   4 +-
 .../flashdreams/api_v2/client_window.py       |   5 +
 .../runtime_v2/file_selection_gate.py         | 220 ++++++++++++++++--
 .../runtime_v2/native_window_client_window.py | 150 +++++++++---
 .../flashdreams/runtime_v2/serving/web/app.js |   6 +
 .../runtime_v2/serving/webrtc_server.py       | 127 +++++++++-
 .../runtime_v2/webrtc_client_window.py        |  84 ++++++-
 .../test_native_window_client_window.py       | 214 +++++++++++++++--
 flashdreams/test_v2/test_selected_files.py    |  44 +++-
 .../test_v2/test_webrtc_client_window.py      |  92 ++++++++
 integrations_v2/imgui_ui_demo/README.md       |   4 +-
 11 files changed, 858 insertions(+), 92 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index f89205988..4a79c36c4 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -235,7 +235,9 @@ one. Using an id twice in one tick raises `ValueError`. `accept` is filename suf
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
-`runtime_v2/selected_file.py`.
+`runtime_v2/selected_file.py`. The status is `UNAVAILABLE` when the client
+cannot show a picker, or does not show one within 300 seconds. Once a picker
+is shown, the user may take as long as they want.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 1bcfee1dc..933da1c6c 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -66,6 +66,11 @@ def request_selected_files(
         :meth:`InputSource.get_user_input_events`. The default has no
         selector and returns ``UNAVAILABLE``.
 
+        Do not block. Answer ``UNAVAILABLE`` when the host rejects the request,
+        fails, or does not show a picker within a bounded time. Once a picker
+        is shown, wait for the user without a deadline, and never close that
+        picker from here.
+
         Args:
             request: Selector request queued by the UI loop.
 
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
index c72f5f150..1811294e2 100644
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -8,12 +8,21 @@
 import logging
 import threading
 from collections import deque
+from collections.abc import Callable
 from dataclasses import dataclass, replace
 
 from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 
 _LOGGER = logging.getLogger(__name__)
 
+FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS = 300.0
+"""Seconds to wait for the host to show a picker before answering ``UNAVAILABLE``.
+
+The deadline starts when a request is handed to the host. After the host reports
+that the picker is presented, the user may take as long as they want. The
+deadline does not close a picker that is already open.
+"""
+
 
 @dataclass(frozen=True, slots=True)
 class QueuedFileSelection:
@@ -49,14 +58,25 @@ def from_request(cls, request: FileSelectionRequest) -> QueuedFileSelection:
         )
 
 
+@dataclass(frozen=True, slots=True)
+class FileSelectionAdmission:
+    """What the window should do with one submitted file-selector request."""
+
+    started: QueuedFileSelection | None = None
+    """Request to hand to the host now, or ``None`` when it is not starting."""
+
+    unavailable: bool = False
+    """Answer this submit with ``UNAVAILABLE`` and do not open another picker."""
+
+
 class FileSelectionGate:
-    """Admit one client file selector at a time.
+    """Run one file picker at a time; later requests wait in a queue.
 
-    A duplicate ``request_id`` that is already active or queued is ignored.
-    A different id waits until :meth:`complete` for the active request.
-    Callers emit a selected-files event only after :meth:`complete` claims
-    the slot. :meth:`drain` finishes the current client generation so late
-    in-flight work cannot complete a later request that reused the id.
+    - A repeated ``request_id`` is ignored.
+    - :meth:`complete` frees the slot and says whether to deliver the result.
+    - :meth:`expire_presentation` answers a picker that never appeared, but
+      keeps the slot until the host finishes, so two pickers never overlap.
+    - :meth:`drain` drops everything, so late results cannot match new requests.
     """
 
     def __init__(self) -> None:
@@ -65,16 +85,20 @@ def __init__(self) -> None:
         self._active: QueuedFileSelection | None = None
         self._queued: deque[QueuedFileSelection] = deque()
         self._generation = 0
+        self._presented = False
+        self._answered = False
 
-    def submit(self, pending: QueuedFileSelection) -> QueuedFileSelection | None:
-        """Record ``pending`` and return it when it should start now.
+    def submit(self, pending: QueuedFileSelection) -> FileSelectionAdmission:
+        """Record ``pending`` and return whether it should start now.
 
         Args:
             pending: Request the window wants to show.
 
         Returns:
-            ``pending`` when no selector is active, otherwise ``None`` when the
-            id is a duplicate or the request was queued behind the active one.
+            An admission whose ``started`` request is handed to the host when
+            no selector is active. ``unavailable`` is set when a previous
+            picker was already answered but the host has not finished.
+            Otherwise the request was queued or ignored as a duplicate.
         """
         with self._lock:
             if self._contains(pending.request_id):
@@ -82,20 +106,67 @@ def submit(self, pending: QueuedFileSelection) -> QueuedFileSelection | None:
                     "Ignoring duplicate file-selection request id %r.",
                     pending.request_id,
                 )
-                return None
+                return FileSelectionAdmission()
+            if self._active is not None and self._answered:
+                return FileSelectionAdmission(unavailable=True)
             stamped = replace(pending, generation=self._generation)
             if self._active is None:
                 self._active = stamped
-                return stamped
+                self._presented = False
+                self._answered = False
+                return FileSelectionAdmission(started=stamped)
             self._queued.append(stamped)
-            return None
+            return FileSelectionAdmission()
+
+    def mark_presented(self, request_id: str, generation: int) -> bool:
+        """Record that the host showed ``request_id``.
+
+        Returns:
+            ``True`` when this request is still waiting for that signal.
+        """
+        with self._lock:
+            if not self._is_active(request_id, generation) or self._answered:
+                return False
+            self._presented = True
+            return True
+
+    def may_show(self, request_id: str, generation: int) -> bool:
+        """Return whether the host should still be asked to show this request."""
+        with self._lock:
+            return self._is_active(request_id, generation) and not self._answered
+
+    def expire_presentation(
+        self, request_id: str, generation: int
+    ) -> tuple[QueuedFileSelection, ...]:
+        """Answer an unpresented request and every request waiting behind it.
+
+        The active slot stays occupied until :meth:`complete` so the window
+        does not open another picker while this host might still show one.
+
+        Returns:
+            Requests the window should answer as ``UNAVAILABLE``. Empty when
+            the request is no longer current or the host already presented it.
+        """
+        with self._lock:
+            if (
+                not self._is_active(request_id, generation)
+                or self._presented
+                or self._answered
+            ):
+                return ()
+            self._answered = True
+            expired = [self._active, *self._queued]
+            self._queued.clear()
+            return tuple(item for item in expired if item is not None)
 
     def complete(
         self, request_id: str, generation: int | None = None
     ) -> tuple[bool, QueuedFileSelection | None]:
-        """Claim ``request_id`` if it is still current and return the next start.
+        """Release ``request_id`` if it is still current and return the next start.
 
-        Callers emit a result only when this returns ``claimed=True``. Client-gone
+        Callers emit the host result only when this returns ``deliver=True``.
+        A request already answered by :meth:`expire_presentation` still releases
+        the slot, but its host result is not delivered. Client-gone
         :meth:`drain` wins the race against in-flight work.
 
         Args:
@@ -104,21 +175,26 @@ def complete(
                 match only the id.
 
         Returns:
-            ``(True, next)`` when this in-flight work still owned the slot.
+            ``(True, next)`` when the host result should be delivered.
             ``next`` is the request that should start now, or ``None`` if the
-            queue is empty. ``(False, None)`` when the id is not current.
+            queue is empty. ``(False, next)`` when the slot was released but
+            the app already has a result. ``(False, None)`` when the id is
+            not current.
         """
         with self._lock:
             if self._active is None or self._active.request_id != request_id:
                 return False, None
             if generation is not None and self._active.generation != generation:
                 return False, None
+            deliver = not self._answered
             self._active = None
+            self._presented = False
+            self._answered = False
             if not self._queued:
-                return True, None
+                return deliver, None
             nxt = self._queued.popleft()
             self._active = nxt
-            return True, nxt
+            return deliver, nxt
 
     def is_current(self, request_id: str, generation: int) -> bool:
         """Return whether ``request_id`` is still the active selector for ``generation``."""
@@ -130,14 +206,20 @@ def is_current(self, request_id: str, generation: int) -> bool:
             )
 
     def drain(self) -> tuple[QueuedFileSelection, ...]:
-        """Return and drop remaining requests, then start a new client generation."""
+        """Return unanswered requests, then start a new client generation.
+
+        A request already answered by :meth:`expire_presentation` is dropped
+        here without being returned again.
+        """
         with self._lock:
             items: list[QueuedFileSelection] = []
-            if self._active is not None:
+            if self._active is not None and not self._answered:
                 items.append(self._active)
             items.extend(self._queued)
             self._active = None
             self._queued.clear()
+            self._presented = False
+            self._answered = False
             self._generation += 1
             return tuple(items)
 
@@ -149,3 +231,99 @@ def _contains(self, request_id: str) -> bool:
         if self._active is not None and self._active.request_id == request_id:
             return True
         return any(item.request_id == request_id for item in self._queued)
+
+    def _is_active(self, request_id: str, generation: int) -> bool:
+        return (
+            self._active is not None
+            and self._active.request_id == request_id
+            and self._active.generation == generation
+        )
+
+
+class FileSelectionPresentationTimer:
+    """Fail one request when the host does not show its picker in time."""
+
+    def __init__(
+        self,
+        gate: FileSelectionGate,
+        *,
+        timeout_seconds: float,
+        on_expired: Callable[[tuple[QueuedFileSelection, ...]], None],
+    ) -> None:
+        """Arm deadlines against ``gate``.
+
+        Args:
+            gate: Queue whose active request this timer watches.
+            timeout_seconds: Presentation deadline. Must be positive.
+            on_expired: Called with the requests to answer as ``UNAVAILABLE``.
+
+        Raises:
+            ValueError: ``timeout_seconds`` is not positive.
+        """
+        if timeout_seconds <= 0:
+            raise ValueError("presentation_timeout_seconds must be > 0.")
+        self._gate = gate
+        self._timeout_seconds = timeout_seconds
+        self._on_expired = on_expired
+        self._lock = threading.Lock()
+        self._timer: threading.Timer | None = None
+        self._token: tuple[str, int] | None = None
+
+    def arm(self, pending: QueuedFileSelection) -> None:
+        """Start the presentation deadline for ``pending``."""
+        self.cancel()
+        token = (pending.request_id, pending.generation)
+        timer = threading.Timer(
+            self._timeout_seconds,
+            self._fire,
+            args=token,
+        )
+        timer.daemon = True
+        with self._lock:
+            self._timer = timer
+            self._token = token
+        timer.start()
+
+    def presented(self, request_id: str, generation: int) -> None:
+        """Cancel the deadline when the host has shown this request."""
+        if self._gate.mark_presented(request_id, generation):
+            self._cancel_if(request_id, generation)
+
+    def finished(self, request_id: str, generation: int) -> None:
+        """Cancel the deadline because the host finished this request."""
+        self._cancel_if(request_id, generation)
+
+    def cancel(self) -> None:
+        """Cancel the current deadline, if one is armed."""
+        with self._lock:
+            timer = self._timer
+            self._timer = None
+            self._token = None
+        if timer is not None:
+            timer.cancel()
+
+    def _cancel_if(self, request_id: str, generation: int) -> None:
+        with self._lock:
+            if self._token != (request_id, generation):
+                return
+            timer = self._timer
+            self._timer = None
+            self._token = None
+        if timer is not None:
+            timer.cancel()
+
+    def _fire(self, request_id: str, generation: int) -> None:
+        with self._lock:
+            if self._token != (request_id, generation):
+                return
+            self._timer = None
+            self._token = None
+        expired = self._gate.expire_presentation(request_id, generation)
+        if not expired:
+            return
+        _LOGGER.warning(
+            "File selector %r was not presented within %g seconds.",
+            request_id,
+            self._timeout_seconds,
+        )
+        self._on_expired(expired)
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 4ccacbd88..3ac69466f 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -27,7 +27,9 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.file_selection_gate import (
+    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
     FileSelectionGate,
+    FileSelectionPresentationTimer,
     QueuedFileSelection,
 )
 from flashdreams.runtime_v2.selected_file import (
@@ -62,18 +64,28 @@ def _ask_open_filename(
     initial_dir: str,
     accept: tuple[str, ...] = (),
     multiple: bool = False,
+    on_presented: Callable[[], None] | None = None,
 ) -> tuple[str, ...]:
     """Return paths from the OS file picker, or an empty tuple when cancelled.
 
+    ``on_presented`` runs once this process has handed the request to a running
+    chooser. It does not mean a remote host made that chooser visible.
+
     Raises:
         RuntimeError: The desktop chooser is missing or failed.
     """
     if sys.platform.startswith("linux"):
         return _ask_open_filename_linux(
-            initial_dir=initial_dir, accept=accept, multiple=multiple
+            initial_dir=initial_dir,
+            accept=accept,
+            multiple=multiple,
+            on_presented=on_presented,
         )
     return _ask_open_filename_tkinter(
-        initial_dir=initial_dir, accept=accept, multiple=multiple
+        initial_dir=initial_dir,
+        accept=accept,
+        multiple=multiple,
+        on_presented=on_presented,
     )
 
 
@@ -87,6 +99,7 @@ def _ask_open_filename_linux(
     initial_dir: str,
     accept: tuple[str, ...] = (),
     multiple: bool = False,
+    on_presented: Callable[[], None] | None = None,
 ) -> tuple[str, ...]:
     """Open the desktop file picker via ``zenity`` or ``kdialog``.
 
@@ -111,7 +124,9 @@ def _ask_open_filename_linux(
         if patterns:
             argv.append(f"--file-filter=Accepted | {patterns}")
         return _parse_chooser_stdout(
-            _run_desktop_chooser(argv), multiple=multiple, quoted=False
+            _run_desktop_chooser(argv, on_presented=on_presented),
+            multiple=multiple,
+            quoted=False,
         )
     kdialog = shutil.which("kdialog")
     if kdialog is None:
@@ -125,17 +140,45 @@ def _ask_open_filename_linux(
     if patterns:
         argv.append(f"Accepted ({patterns})")
     return _parse_chooser_stdout(
-        _run_desktop_chooser(argv), multiple=multiple, quoted=True
+        _run_desktop_chooser(argv, on_presented=on_presented),
+        multiple=multiple,
+        quoted=True,
     )
 
 
-def _run_desktop_chooser(argv: list[str]) -> subprocess.CompletedProcess[str]:
-    """Run one desktop file chooser and map non-cancel failures to errors."""
-    completed = subprocess.run(
+def _run_desktop_chooser(
+    argv: list[str],
+    *,
+    on_presented: Callable[[], None] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    """Run one desktop file chooser and map non-cancel failures to errors.
+
+    A process that is still running counts as presented. The chooser is not
+    killed if the caller later stops waiting for it.
+    """
+    # ponytail: process start is the presentation signal. A host that launches
+    # the chooser and then hides it is indistinguishable from a user who has
+    # not finished. Upgrade path: IFileDialogEvents, NSOpenPanel visibility,
+    # or an XDG portal request handle.
+    try:
+        process = subprocess.Popen(
+            argv,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except OSError as exc:
+        raise RuntimeError("Native file picker failed to start.") from exc
+    if process.poll() is None and on_presented is not None:
+        on_presented()
+    stdout, stderr = process.communicate()
+    if process.returncode is None:
+        raise RuntimeError("Native file picker ended without a status.")
+    completed = subprocess.CompletedProcess(
         argv,
-        check=False,
-        capture_output=True,
-        text=True,
+        process.returncode,
+        stdout or "",
+        stderr or "",
     )
     if completed.returncode == 1:
         return completed
@@ -181,6 +224,7 @@ def _ask_open_filename_tkinter(
     initial_dir: str,
     accept: tuple[str, ...] = (),
     multiple: bool = False,
+    on_presented: Callable[[], None] | None = None,
 ) -> tuple[str, ...]:
     """Open the Tk file dialog (native Explorer / macOS panel)."""
     import tkinter as tk
@@ -192,6 +236,10 @@ def _ask_open_filename_tkinter(
         root.attributes("-topmost", True)
     except tk.TclError:
         pass
+    # ponytail: calling the Tk dialog is the presentation signal. Tk does not
+    # report when Explorer or the macOS panel is actually visible.
+    if on_presented is not None:
+        on_presented()
     try:
         kwargs: dict[str, Any] = {
             "initialdir": initial_dir,
@@ -312,6 +360,9 @@ def __init__(
         title: str = "FlashDreams",
         presenter_factory: Callable[..., _SlangPyNativeWindowPresenter] | None = None,
         clock_ns: Callable[[], int] = time.monotonic_ns,
+        presentation_timeout_seconds: float = (
+            FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
+        ),
     ) -> None:
         """Configure the native client window.
 
@@ -319,9 +370,13 @@ def __init__(
             title: Native window title.
             presenter_factory: Optional SlangPy-compatible presenter factory.
             clock_ns: Monotonic clock used for input timestamps.
+            presentation_timeout_seconds: How long to wait for the OS chooser
+                to start. After it starts, the user may take as long as they
+                want.
 
         Raises:
-            ValueError: ``title`` is empty.
+            ValueError: ``title`` is empty or the presentation deadline is not
+                positive.
         """
         if not title.strip():
             raise ValueError("Native-window title must be non-empty.")
@@ -342,6 +397,11 @@ def __init__(
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._file_gate = FileSelectionGate()
+        self._presentation = FileSelectionPresentationTimer(
+            self._file_gate,
+            timeout_seconds=presentation_timeout_seconds,
+            on_expired=self._on_file_selection_unpresented,
+        )
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the native window."""
@@ -382,18 +442,37 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the OS file selector and enqueue the chosen files."""
-        started = self._file_gate.submit(
+        admission = self._file_gate.submit(
             replace(
                 QueuedFileSelection.from_request(request),
                 initial_path=request.initial_path or str(Path.home()),
                 max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
             )
         )
-        if started is not None:
-            self._spawn_file_picker(started)
+        if admission.unavailable:
+            self._enqueue_selected_files(
+                request.request_id,
+                generation=0,
+                status=SelectedFilesStatus.UNAVAILABLE,
+            )
+            return
+        if admission.started is not None:
+            self._spawn_file_picker(admission.started)
+
+    def _on_file_selection_unpresented(
+        self, expired: tuple[QueuedFileSelection, ...]
+    ) -> None:
+        """Answer requests whose chooser did not start in time."""
+        for item in expired:
+            self._enqueue_selected_files(
+                item.request_id,
+                generation=item.generation,
+                status=SelectedFilesStatus.UNAVAILABLE,
+            )
 
     def _spawn_file_picker(self, pending: QueuedFileSelection) -> None:
         """Run one OS picker on a worker thread."""
+        self._presentation.arm(pending)
         worker = threading.Thread(
             target=self._complete_file_selection,
             args=(
@@ -429,6 +508,9 @@ def _complete_file_selection(
                     initial_dir=initial_dir,
                     accept=accept,
                     multiple=multiple,
+                    on_presented=lambda: self._presentation.presented(
+                        request_id, generation
+                    ),
                 )
             except Exception:
                 _LOGGER.exception(
@@ -447,20 +529,14 @@ def _complete_file_selection(
                 else:
                     status = SelectedFilesStatus.CANCELLED
         finally:
+            self._presentation.finished(request_id, generation)
             claimed, nxt = self._file_gate.complete(request_id, generation)
             if claimed:
-                started_ns = self._session_started_ns
-                elapsed_ns = (
-                    0 if started_ns is None else max(0, self._clock_ns() - started_ns)
-                )
-                self._input_events.put(
-                    SelectedFilesUserInputEvent(
-                        timestamp=uint64(elapsed_ns // 1_000),
-                        request_id=request_id,
-                        status=status,
-                        files=files,
-                        _generation=generation,
-                    )
+                self._enqueue_selected_files(
+                    request_id,
+                    generation=generation,
+                    status=status,
+                    files=files,
                 )
             if nxt is not None and self._presenter is not None:
                 self._spawn_file_picker(nxt)
@@ -686,8 +762,30 @@ def _on_window_closed(self) -> None:
         self._invalidate_file_selections(deliver_unavailable=True)
         self._put_input(CloseUserInputEvent(timestamp=uint64(0)))
 
+    def _enqueue_selected_files(
+        self,
+        request_id: str,
+        *,
+        generation: int,
+        status: SelectedFilesStatus,
+        files: tuple[SelectedFile, ...] = (),
+    ) -> None:
+        """Queue one selected-files event from any thread."""
+        started_ns = self._session_started_ns
+        elapsed_ns = 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
+        self._input_events.put(
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(elapsed_ns // 1_000),
+                request_id=request_id,
+                status=status,
+                files=files,
+                _generation=generation,
+            )
+        )
+
     def _invalidate_file_selections(self, *, deliver_unavailable: bool) -> None:
         """Finish this client generation; optionally report leftovers as unavailable."""
+        self._presentation.cancel()
         leftover = self._file_gate.drain()
         if not deliver_unavailable:
             return
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 288e8b167..f790ba91c 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -382,6 +382,12 @@ const openFileSelector = options => {
       hideFilePicker();
     },
   });
+  if (promptDialog === null || !promptDialog.open) {
+    completeFileSelection(requestId, "unavailable");
+    hideFilePicker();
+    return;
+  }
+  send({type: "file_selector_ack", id: requestId});
 };
 
 window.addEventListener("focus", updateCursorVisibility);
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 253406bfc..c982b1e2a 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -322,6 +322,14 @@ class _PendingFileSelection:
     """Gate generation that armed this request; a later generation drops it."""
 
 
+def _queued_file_selector_matches(
+    item: tuple[dict[str, Any], int], request_id: str, generation: int
+) -> bool:
+    """Return whether one queued selector payload is this request."""
+    payload, queued_generation = item
+    return payload.get("id") == request_id and queued_generation == generation
+
+
 class WebRTCServer:
     """Own the HTTP, signaling, input buffering, and media transport."""
 
@@ -354,6 +362,10 @@ def __init__(
         self._startup_timeout_seconds = startup_timeout_seconds
         self._input_callback: Callable[[UserInputEvent], None] | None = None
         self._file_selection_current_callback: Callable[[str, int], bool] | None = None
+        self._file_selection_may_show_callback: Callable[[str, int], bool] | None = None
+        self._file_selection_presented_callback: Callable[[str, int], None] | None = (
+            None
+        )
         self._file_selection_invalidate_callback: Callable[[bool], None] | None = None
         self._started = threading.Event()
         self._startup_error: BaseException | None = None
@@ -378,6 +390,7 @@ def __init__(
         self._lock_cursor_to_window = False
         self._queued_file_selectors: list[tuple[dict[str, Any], int]] = []
         self._pending_file_requests: dict[str, _PendingFileSelection] = {}
+        self._file_selector_sent: set[tuple[str, int]] = set()
         self._file_selector_lock = threading.Lock()
         self._thread = threading.Thread(
             target=self._run_server,
@@ -523,7 +536,7 @@ def _arm_file_selector(self, payload: dict[str, Any], generation: int) -> None:
                 "file selector payload must include accept, max_bytes, and multiple."
             )
         with self._file_selector_lock:
-            if not self._file_selection_is_current(request_id, generation):
+            if not self._file_selection_may_show(request_id, generation):
                 return
             self._pending_file_requests[request_id] = _PendingFileSelection(
                 accept=tuple(accept),
@@ -535,6 +548,7 @@ def _arm_file_selector(self, payload: dict[str, Any], generation: int) -> None:
             if channel is None or channel.readyState != "open":
                 self._queued_file_selectors.append((payload, generation))
                 return
+            self._file_selector_sent.add((request_id, generation))
         channel.send(json.dumps(payload))
 
     def _take_pending_file_request(
@@ -542,7 +556,10 @@ def _take_pending_file_request(
     ) -> _PendingFileSelection | None:
         """Return and consume the policy for ``request_id``, if it was pending."""
         with self._file_selector_lock:
-            return self._pending_file_requests.pop(request_id, None)
+            policy = self._pending_file_requests.pop(request_id, None)
+            if policy is not None:
+                self._file_selector_sent.discard((request_id, policy.generation))
+            return policy
 
     def _file_selection_is_current(self, request_id: str, generation: int) -> bool:
         """Return whether the window gate still owns this in-flight request."""
@@ -553,15 +570,60 @@ def _file_selection_is_current(self, request_id: str, generation: int) -> bool:
             return False
         return callback(request_id, generation)
 
+    def _file_selection_may_show(self, request_id: str, generation: int) -> bool:
+        """Return whether this request should still be sent to the browser."""
+        if self._closed:
+            return False
+        callback = self._file_selection_may_show_callback
+        if callback is None:
+            return False
+        return callback(request_id, generation)
+
+    def _note_file_selector_presented(self, payload: dict[str, Any]) -> None:
+        """Forward a browser acknowledgement that the picker prompt is visible."""
+        request_id = payload.get("id")
+        if not isinstance(request_id, str) or not request_id:
+            raise ValueError("File selector acknowledgement requires a non-empty id.")
+        with self._file_selector_lock:
+            policy = self._pending_file_requests.get(request_id)
+        if policy is None or not self._file_selection_is_current(
+            request_id, policy.generation
+        ):
+            return
+        callback = self._file_selection_presented_callback
+        if callback is not None:
+            callback(request_id, policy.generation)
+
     def _invalidate_file_selectors(self, *, deliver_unavailable: bool) -> None:
         """Drop transport state and finish the window's current file generation."""
         with self._file_selector_lock:
             self._pending_file_requests.clear()
             self._queued_file_selectors.clear()
+            self._file_selector_sent.clear()
             callback = self._file_selection_invalidate_callback
             if callback is not None:
                 callback(deliver_unavailable)
 
+    def drop_unsent_file_selector(self, request_id: str, generation: int) -> bool:
+        """Drop a selector that has not been sent to the browser.
+
+        Returns:
+            ``True`` when nothing was sent, so the window can release the
+            request. ``False`` when the browser may already be showing it.
+        """
+        with self._file_selector_lock:
+            if (request_id, generation) in self._file_selector_sent:
+                return False
+            self._queued_file_selectors = [
+                item
+                for item in self._queued_file_selectors
+                if not _queued_file_selector_matches(item, request_id, generation)
+            ]
+            pending = self._pending_file_requests.get(request_id)
+            if pending is not None and pending.generation == generation:
+                self._pending_file_requests.pop(request_id, None)
+            return True
+
     def _complete_abandoned_file_selectors(self) -> None:
         """Finish leftover picks because the interactive client is gone."""
         self._invalidate_file_selectors(deliver_unavailable=True)
@@ -574,20 +636,35 @@ def _flush_queued_file_selectors(self) -> None:
             ready: list[tuple[dict[str, Any], int]] = []
             for payload, generation in queued:
                 request_id = payload["id"]
-                if isinstance(request_id, str) and self._file_selection_is_current(
+                if isinstance(request_id, str) and self._file_selection_may_show(
                     request_id, generation
                 ):
                     ready.append((payload, generation))
+                elif isinstance(request_id, str):
+                    pending = self._pending_file_requests.get(request_id)
+                    if pending is not None and pending.generation == generation:
+                        self._pending_file_requests.pop(request_id, None)
         for payload, generation in ready:
             channel = self._control_channel
-            if channel is None or channel.readyState != "open":
+            request_id = payload["id"]
+            if (
+                channel is None
+                or channel.readyState != "open"
+                or not isinstance(request_id, str)
+            ):
                 with self._file_selector_lock:
-                    request_id = payload["id"]
-                    if isinstance(request_id, str) and self._file_selection_is_current(
+                    if isinstance(request_id, str) and self._file_selection_may_show(
                         request_id, generation
                     ):
                         self._queued_file_selectors.append((payload, generation))
                 continue
+            with self._file_selector_lock:
+                if not self._file_selection_may_show(request_id, generation):
+                    pending = self._pending_file_requests.get(request_id)
+                    if pending is not None and pending.generation == generation:
+                        self._pending_file_requests.pop(request_id, None)
+                    continue
+                self._file_selector_sent.add((request_id, generation))
             channel.send(json.dumps(payload))
 
     def event_timestamp_us(self) -> np.uint64:
@@ -727,6 +804,41 @@ def register_file_selection_current_callback(
             )
         self._file_selection_current_callback = callback
 
+    def register_file_selection_may_show_callback(
+        self, callback: Callable[[str, int], bool]
+    ) -> None:
+        """Register the check for whether a selector should still be sent.
+
+        Args:
+            callback: ``True`` when ``request_id`` is current and the app is
+                still waiting for the browser to show it.
+
+        Raises:
+            RuntimeError: A callback has already been registered.
+        """
+        if self._file_selection_may_show_callback is not None:
+            raise RuntimeError(
+                "A file-selection may-show callback is already registered."
+            )
+        self._file_selection_may_show_callback = callback
+
+    def register_file_selection_presented_callback(
+        self, callback: Callable[[str, int], None]
+    ) -> None:
+        """Register the function called when the browser shows a picker prompt.
+
+        Args:
+            callback: Receives the request id and gate generation.
+
+        Raises:
+            RuntimeError: A callback has already been registered.
+        """
+        if self._file_selection_presented_callback is not None:
+            raise RuntimeError(
+                "A file-selection presented callback is already registered."
+            )
+        self._file_selection_presented_callback = callback
+
     def register_file_selection_invalidate_callback(
         self, callback: Callable[[bool], None]
     ) -> None:
@@ -1384,6 +1496,9 @@ def _buffer_browser_message(
             event = ResetUserInputEvent(timestamp=timestamp_us)
         elif event_type == "close":
             event = CloseUserInputEvent(timestamp=timestamp_us)
+        elif event_type == "file_selector_ack":
+            self._note_file_selector_presented(payload)
+            return
         elif event_type == "file_selector_result":
             request_id = payload.get("id")
             if not isinstance(request_id, str) or not request_id:
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index cddbd0def..c2b5a80d6 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -11,7 +11,9 @@
 
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.runtime_v2.file_selection_gate import (
+    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
     FileSelectionGate,
+    FileSelectionPresentationTimer,
     QueuedFileSelection,
 )
 from flashdreams.runtime_v2.selected_file import (
@@ -53,6 +55,9 @@ def __init__(
         host: str = "127.0.0.1",
         port: int = 0,
         startup_timeout_seconds: float = 10.0,
+        presentation_timeout_seconds: float = (
+            FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
+        ),
     ) -> None:
         """Create the WebRTC backend.
 
@@ -63,11 +68,22 @@ def __init__(
             host: Interface on which the HTTP server listens.
             port: Listening port. Zero asks the operating system to choose one.
             startup_timeout_seconds: Maximum time to wait for server startup.
+            presentation_timeout_seconds: How long to wait for the browser to
+                show the picker prompt. After that acknowledgement, the user
+                may take as long as they want.
+
+        Raises:
+            ValueError: The presentation deadline is not positive.
         """
         self._input_events: deque[UserInputEvent] = deque()
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._file_gate = FileSelectionGate()
+        self._presentation = FileSelectionPresentationTimer(
+            self._file_gate,
+            timeout_seconds=presentation_timeout_seconds,
+            on_expired=self._on_file_selection_unpresented,
+        )
         self._input_lock = threading.Lock()
         # Offset from the server's stable clock to the current session's clock.
         self._session_event_offset_us = uint64(0)
@@ -83,17 +99,23 @@ def handle_input(event: UserInputEvent) -> None:
             nxt = None
             with self._input_lock:
                 if isinstance(event, SelectedFilesUserInputEvent):
+                    self._presentation.finished(event.request_id, event._generation)
                     claimed, nxt = self._file_gate.complete(
                         event.request_id, event._generation
                     )
-                    if not claimed:
-                        return
-                self._input_events.append(event)
+                    if claimed:
+                        self._input_events.append(event)
+                else:
+                    self._input_events.append(event)
             if nxt is not None:
                 self._start_file_selection(nxt)
 
         self.server.register_input_callback(handle_input)
         self.server.register_file_selection_current_callback(self._file_gate.is_current)
+        self.server.register_file_selection_may_show_callback(self._file_gate.may_show)
+        self.server.register_file_selection_presented_callback(
+            self._presentation.presented
+        )
         self.server.register_file_selection_invalidate_callback(
             self._invalidate_file_selections
         )
@@ -128,12 +150,61 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the connected browser to open a file selector."""
-        started = self._file_gate.submit(QueuedFileSelection.from_request(request))
-        if started is not None:
-            self._start_file_selection(started)
+        admission = self._file_gate.submit(QueuedFileSelection.from_request(request))
+        if admission.unavailable:
+            self._append_unavailable(request.request_id, generation=0)
+            return
+        if admission.started is not None:
+            self._start_file_selection(admission.started)
+
+    def _on_file_selection_unpresented(
+        self, expired: tuple[QueuedFileSelection, ...]
+    ) -> None:
+        """Answer requests whose browser prompt was not shown in time.
+
+        A prompt that was never sent does not need to keep the picker slot.
+        A prompt that was sent might still appear, so that slot stays occupied
+        until the browser finishes and the late result is discarded.
+        """
+        if not expired:
+            return
+        timestamp = self.server.event_timestamp_us()
+        with self._input_lock:
+            for item in expired:
+                self._input_events.append(
+                    SelectedFilesUserInputEvent(
+                        timestamp=timestamp,
+                        request_id=item.request_id,
+                        status=SelectedFilesStatus.UNAVAILABLE,
+                        _generation=item.generation,
+                    )
+                )
+        active = expired[0]
+        if not self.server.drop_unsent_file_selector(
+            active.request_id, active.generation
+        ):
+            return
+        self._presentation.finished(active.request_id, active.generation)
+        _delivered, nxt = self._file_gate.complete(active.request_id, active.generation)
+        if nxt is not None:
+            self._start_file_selection(nxt)
+
+    def _append_unavailable(self, request_id: str, *, generation: int) -> None:
+        """Queue one unavailable file-selector result."""
+        timestamp = self.server.event_timestamp_us()
+        with self._input_lock:
+            self._input_events.append(
+                SelectedFilesUserInputEvent(
+                    timestamp=timestamp,
+                    request_id=request_id,
+                    status=SelectedFilesStatus.UNAVAILABLE,
+                    _generation=generation,
+                )
+            )
 
     def _invalidate_file_selections(self, deliver_unavailable: bool) -> None:
         """Finish this client generation; optionally report leftovers as unavailable."""
+        self._presentation.cancel()
         leftover = self._file_gate.drain()
         if not deliver_unavailable or not leftover:
             return
@@ -151,6 +222,7 @@ def _invalidate_file_selections(self, deliver_unavailable: bool) -> None:
 
     def _start_file_selection(self, pending: QueuedFileSelection) -> None:
         """Arm the WebRTC server for one file-selector request."""
+        self._presentation.arm(pending)
         self.server.request_selected_files(
             pending.request_id,
             initial_path=pending.initial_path,
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index c3749e63a..dbbc96290 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -61,6 +61,42 @@ def _file_request(
     )
 
 
+class _ChooserProcess:
+    """Desktop chooser stand-in that has already exited."""
+
+    def __init__(self, *, returncode: int, stdout: str = "", stderr: str = "") -> None:
+        self.returncode = returncode
+        self._stdout = stdout
+        self._stderr = stderr
+
+    def poll(self) -> int:
+        """Return the exit status. The process is already finished."""
+        return self.returncode
+
+    def communicate(self, timeout: float | None = None) -> tuple[str, str]:
+        """Return the captured chooser output."""
+        del timeout
+        return self._stdout, self._stderr
+
+
+class _RunningChooser:
+    """Chooser process that stays alive until ``communicate``."""
+
+    def __init__(self, *, stdout: str) -> None:
+        self.returncode: int | None = None
+        self._stdout = stdout
+
+    def poll(self) -> None:
+        """Report that the chooser is still running."""
+        return None
+
+    def communicate(self, timeout: float | None = None) -> tuple[str, str]:
+        """Finish the chooser and return its output."""
+        del timeout
+        self.returncode = 0
+        return self._stdout, ""
+
+
 def _wait_for_input_events(window: NativeWindowClientWindow) -> list[object]:
     for _ in range(100):
         events = window.get_user_input_events().get_events()
@@ -655,7 +691,9 @@ def test_native_window_reports_a_selected_file(
     monkeypatch.setattr(
         native_window_module,
         "_ask_open_filename",
-        lambda *, initial_dir, accept=(), multiple=False: (str(chosen),),
+        lambda *, initial_dir, accept=(), multiple=False, on_presented=None: (
+            str(chosen),
+        ),
     )
     presenter = _Presenter()
     window = NativeWindowClientWindow(
@@ -681,7 +719,7 @@ def test_native_window_reports_cancelled_file_selection(
     monkeypatch.setattr(
         native_window_module,
         "_ask_open_filename",
-        lambda *, initial_dir, accept=(), multiple=False: (),
+        lambda *, initial_dir, accept=(), multiple=False, on_presented=None: (),
     )
     presenter = _Presenter()
     window = NativeWindowClientWindow(
@@ -708,8 +746,9 @@ def fail_picker(
         initial_dir: str,
         accept: tuple[str, ...] = (),
         multiple: bool = False,
+        on_presented: object = None,
     ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple
+        del initial_dir, accept, multiple, on_presented
         raise RuntimeError("Native file picker needs a desktop chooser.")
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", fail_picker)
@@ -742,8 +781,9 @@ def picker(
         initial_dir: str,
         accept: tuple[str, ...] = (),
         multiple: bool = False,
+        on_presented: object = None,
     ) -> tuple[str, ...]:
-        del initial_dir, multiple
+        del initial_dir, multiple, on_presented
         calls.append(accept)
         if len(calls) == 1:
             first_entered.set()
@@ -793,8 +833,9 @@ def picker(
         initial_dir: str,
         accept: tuple[str, ...] = (),
         multiple: bool = False,
+        on_presented: object = None,
     ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple
+        del initial_dir, accept, multiple, on_presented
         calls.append(1)
         entered.set()
         if len(calls) == 1:
@@ -836,8 +877,9 @@ def picker(
         initial_dir: str,
         accept: tuple[str, ...] = (),
         multiple: bool = False,
+        on_presented: object = None,
     ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple
+        del initial_dir, accept, multiple, on_presented
         entered.set()
         assert released.wait(timeout=2.0)
         return (str(late),)
@@ -882,8 +924,9 @@ def picker(
         initial_dir: str,
         accept: tuple[str, ...] = (),
         multiple: bool = False,
+        on_presented: object = None,
     ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple
+        del initial_dir, accept, multiple, on_presented
         calls.append(1)
         entered.set()
         assert released.wait(timeout=2.0)
@@ -926,8 +969,9 @@ def picker(
         initial_dir: str,
         accept: tuple[str, ...] = (),
         multiple: bool = False,
+        on_presented: object = None,
     ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple
+        del initial_dir, accept, multiple, on_presented
         calls.append(1)
         if len(calls) == 1:
             first_entered.set()
@@ -1007,11 +1051,12 @@ def test_ask_open_filename_linux_uses_zenity(
     )
     calls: list[list[str]] = []
 
-    def fake_run(argv: list[str], **kwargs: object) -> object:
+    def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
+        del kwargs
         calls.append(argv)
-        return SimpleNamespace(returncode=0, stdout="/tmp/seed.png\n")
+        return _ChooserProcess(returncode=0, stdout="/tmp/seed.png\n")
 
-    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    monkeypatch.setattr(native_window_module.subprocess, "Popen", fake_popen)
     assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == (
         "/tmp/seed.png",
     )
@@ -1036,8 +1081,8 @@ def test_ask_open_filename_linux_cancel_is_empty(
     )
     monkeypatch.setattr(
         native_window_module.subprocess,
-        "run",
-        lambda argv, **kwargs: SimpleNamespace(returncode=1, stdout=""),
+        "Popen",
+        lambda argv, **kwargs: _ChooserProcess(returncode=1, stdout=""),
     )
     assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == ()
 
@@ -1052,8 +1097,8 @@ def test_ask_open_filename_linux_error_raises(
     )
     monkeypatch.setattr(
         native_window_module.subprocess,
-        "run",
-        lambda argv, **kwargs: SimpleNamespace(
+        "Popen",
+        lambda argv, **kwargs: _ChooserProcess(
             returncode=5, stdout="", stderr="no display"
         ),
     )
@@ -1071,11 +1116,12 @@ def test_ask_open_filename_linux_multiple_uses_slash_separator(
     )
     calls: list[list[str]] = []
 
-    def fake_run(argv: list[str], **kwargs: object) -> object:
+    def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
+        del kwargs
         calls.append(argv)
-        return SimpleNamespace(returncode=0, stdout="/tmp/foo\nbar.bin//tmp/baz.bin\n")
+        return _ChooserProcess(returncode=0, stdout="/tmp/foo\nbar.bin//tmp/baz.bin\n")
 
-    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    monkeypatch.setattr(native_window_module.subprocess, "Popen", fake_popen)
     assert native_window_module._ask_open_filename_linux(
         initial_dir="/tmp", multiple=True
     ) == ("/tmp/foo\nbar.bin", "/tmp/baz.bin")
@@ -1093,11 +1139,12 @@ def test_ask_open_filename_linux_falls_back_to_kdialog(
     )
     calls: list[list[str]] = []
 
-    def fake_run(argv: list[str], **kwargs: object) -> object:
+    def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
+        del kwargs
         calls.append(argv)
-        return SimpleNamespace(returncode=0, stdout="'/tmp/a.bin' '/tmp/b.bin'\n")
+        return _ChooserProcess(returncode=0, stdout="'/tmp/a.bin' '/tmp/b.bin'\n")
 
-    monkeypatch.setattr(native_window_module.subprocess, "run", fake_run)
+    monkeypatch.setattr(native_window_module.subprocess, "Popen", fake_popen)
     assert native_window_module._ask_open_filename_linux(
         initial_dir="/tmp", multiple=True
     ) == ("/tmp/a.bin", "/tmp/b.bin")
@@ -1106,6 +1153,126 @@ def fake_run(argv: list[str], **kwargs: object) -> object:
     assert "--multiple" in calls[0]
 
 
+def test_ask_open_filename_linux_running_chooser_is_presented(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+    presented: list[bool] = []
+    monkeypatch.setattr(
+        native_window_module.subprocess,
+        "Popen",
+        lambda argv, **kwargs: _RunningChooser(stdout="/tmp/seed.png\n"),
+    )
+    assert native_window_module._ask_open_filename_linux(
+        initial_dir="/tmp",
+        on_presented=lambda: presented.append(True),
+    ) == ("/tmp/seed.png",)
+    assert presented == [True]
+
+
+def test_native_window_unpresented_picker_does_not_keep_a_late_result(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    entered = threading.Event()
+    released = threading.Event()
+    chosen = tmp_path / "late.bin"
+    chosen.write_bytes(b"late")
+    calls: list[int] = []
+
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+        on_presented: object = None,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple, on_presented
+        calls.append(1)
+        if len(calls) == 1:
+            entered.set()
+            assert released.wait(timeout=2.0)
+            return (str(chosen),)
+        return ()
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+        presentation_timeout_seconds=0.05,
+    )
+    window.open(_session_desc())
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    assert entered.wait(timeout=2.0)
+    expired = _wait_for_input_events(window)
+    window.request_selected_files(_file_request("open-2", str(tmp_path)))
+    refused = _wait_for_input_events(window)
+    released.set()
+    time.sleep(0.05)
+    late = window.get_user_input_events().get_events()
+    window.request_selected_files(_file_request("open-3", str(tmp_path)))
+    resumed = _wait_for_input_events(window)
+    window.close()
+
+    assert len(expired) == 1
+    assert isinstance(expired[0], SelectedFilesUserInputEvent)
+    assert expired[0].request_id == "open-1"
+    assert expired[0].status is SelectedFilesStatus.UNAVAILABLE
+    assert len(refused) == 1
+    assert isinstance(refused[0], SelectedFilesUserInputEvent)
+    assert refused[0].request_id == "open-2"
+    assert refused[0].status is SelectedFilesStatus.UNAVAILABLE
+    assert late == []
+    assert len(resumed) == 1
+    assert isinstance(resumed[0], SelectedFilesUserInputEvent)
+    assert resumed[0].request_id == "open-3"
+    assert resumed[0].status is SelectedFilesStatus.CANCELLED
+
+
+def test_native_window_presented_picker_waits_past_the_deadline(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    entered = threading.Event()
+    released = threading.Event()
+
+    def picker(
+        *,
+        initial_dir: str,
+        accept: tuple[str, ...] = (),
+        multiple: bool = False,
+        on_presented: Callable[[], None] | None = None,
+    ) -> tuple[str, ...]:
+        del initial_dir, accept, multiple
+        if on_presented is not None:
+            on_presented()
+        entered.set()
+        assert released.wait(timeout=2.0)
+        return ()
+
+    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(
+        presenter_factory=_presenter_factory(presenter),
+        presentation_timeout_seconds=0.05,
+    )
+    window.open(_session_desc())
+    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    assert entered.wait(timeout=2.0)
+    time.sleep(0.12)
+    assert window.get_user_input_events().get_events() == []
+    released.set()
+    events = _wait_for_input_events(window)
+    window.close()
+
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.status is SelectedFilesStatus.CANCELLED
+
+
 def test_ask_open_filename_linux_requires_a_desktop_chooser(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -1124,7 +1291,10 @@ def test_native_window_reports_multiple_selected_files(
     monkeypatch.setattr(
         native_window_module,
         "_ask_open_filename",
-        lambda *, initial_dir, accept=(), multiple=False: (str(first), str(second)),
+        lambda *, initial_dir, accept=(), multiple=False, on_presented=None: (
+            str(first),
+            str(second),
+        ),
     )
     presenter = _Presenter()
     window = NativeWindowClientWindow(
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index b53e2f40e..30ed9cc1a 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -130,10 +130,10 @@ def _queued(request_id: str) -> QueuedFileSelection:
 
 def test_file_selection_gate_ignores_duplicates_and_serves_one_at_a_time() -> None:
     gate = FileSelectionGate()
-    assert gate.submit(_queued("open-1")) is not None
-    assert gate.submit(_queued("open-1")) is None
-    assert gate.submit(_queued("open-2")) is None
-    assert gate.submit(_queued("open-2")) is None
+    assert gate.submit(_queued("open-1")).started is not None
+    assert gate.submit(_queued("open-1")).started is None
+    assert gate.submit(_queued("open-2")).started is None
+    assert gate.submit(_queued("open-2")).started is None
     assert gate.complete("open-2") == (False, None)
     claimed, nxt = gate.complete("open-1")
     assert claimed
@@ -144,8 +144,8 @@ def test_file_selection_gate_ignores_duplicates_and_serves_one_at_a_time() -> No
 
 def test_file_selection_gate_drain_returns_active_then_queued() -> None:
     gate = FileSelectionGate()
-    assert gate.submit(_queued("open-1")) is not None
-    assert gate.submit(_queued("open-2")) is None
+    assert gate.submit(_queued("open-1")).started is not None
+    assert gate.submit(_queued("open-2")).started is None
     claimed, nxt = gate.complete("open-1")
     assert claimed
     assert nxt is not None
@@ -155,11 +155,11 @@ def test_file_selection_gate_drain_returns_active_then_queued() -> None:
 
 def test_file_selection_gate_stale_complete_does_not_release_new_request() -> None:
     gate = FileSelectionGate()
-    first = gate.submit(_queued("open-1"))
+    first = gate.submit(_queued("open-1")).started
     assert first is not None
     stale_generation = first.generation
     gate.drain()
-    second = gate.submit(_queued("open-1"))
+    second = gate.submit(_queued("open-1")).started
     assert second is not None
     assert second.generation != stale_generation
     assert gate.complete("open-1", generation=stale_generation) == (False, None)
@@ -169,13 +169,39 @@ def test_file_selection_gate_stale_complete_does_not_release_new_request() -> No
 
 def test_file_selection_gate_complete_after_drain_is_not_claimed() -> None:
     gate = FileSelectionGate()
-    first = gate.submit(_queued("open-1"))
+    first = gate.submit(_queued("open-1")).started
     assert first is not None
     leftover = gate.drain()
     assert leftover[0].request_id == "open-1"
     assert gate.complete("open-1", first.generation) == (False, None)
 
 
+def test_file_selection_gate_holds_unpresented_request_until_host_finishes() -> None:
+    gate = FileSelectionGate()
+    active = gate.submit(_queued("open-1")).started
+    assert active is not None
+    assert gate.submit(_queued("open-2")).started is None
+    expired = gate.expire_presentation(active.request_id, active.generation)
+    assert [item.request_id for item in expired] == ["open-1", "open-2"]
+    assert gate.may_show(active.request_id, active.generation) is False
+    assert gate.is_current(active.request_id, active.generation)
+    refused = gate.submit(_queued("open-3"))
+    assert refused.started is None
+    assert refused.unavailable
+    assert gate.expire_presentation(active.request_id, active.generation) == ()
+    assert gate.complete(active.request_id, active.generation) == (False, None)
+    assert gate.submit(_queued("open-3")).started is not None
+
+
+def test_file_selection_gate_presented_request_does_not_expire() -> None:
+    gate = FileSelectionGate()
+    active = gate.submit(_queued("open-1")).started
+    assert active is not None
+    assert gate.mark_presented(active.request_id, active.generation)
+    assert gate.expire_presentation(active.request_id, active.generation) == ()
+    assert gate.complete(active.request_id, active.generation) == (True, None)
+
+
 def test_selected_file_policy_helpers() -> None:
     assert clamp_selected_file_max_bytes(None) == MAX_SELECTED_FILE_BYTES
     assert clamp_selected_file_max_bytes(16) == 16
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index df545a610..d0c3c503c 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -571,6 +571,97 @@ async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_unsent_file_selector_times_out_and_releases_the_slot() -> None:
+    window = WebRTCClientWindow(presentation_timeout_seconds=0.05)
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(_file_request("open-1"))
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+        window.request_selected_files(_file_request("open-2"))
+        await _wait_file_armed(window, "open-2")
+    finally:
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_acknowledged_file_selector_waits_past_the_deadline() -> None:
+    window = WebRTCClientWindow(presentation_timeout_seconds=0.3)
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, channel, _ = await _connect_browser(window)
+        window.request_selected_files(_file_request("open-1"))
+        await _wait_file_armed(window, "open-1")
+        channel.send(json.dumps({"type": "file_selector_ack", "id": "open-1"}))
+        await asyncio.sleep(0.45)
+        assert window.get_user_input_events().get_events() == []
+        channel.send(
+            json.dumps(
+                {
+                    "type": "file_selector_result",
+                    "id": "open-1",
+                    "status": "cancelled",
+                }
+            )
+        )
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.CANCELLED
+        assert event.files == ()
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
+@pytest.mark.asyncio
+async def test_sent_file_selector_without_ack_discards_a_late_result() -> None:
+    window = WebRTCClientWindow(presentation_timeout_seconds=0.2)
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, channel, _ = await _connect_browser(window)
+        window.request_selected_files(_file_request("open-1"))
+        await _wait_file_armed(window, "open-1")
+        for _ in range(50):
+            if any(
+                request_id == "open-1"
+                for request_id, _generation in window.server._file_selector_sent
+            ):
+                break
+            await asyncio.sleep(0.01)
+        assert any(
+            request_id == "open-1"
+            for request_id, _generation in window.server._file_selector_sent
+        )
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+        window.request_selected_files(_file_request("open-2"))
+        refused = await _wait_selected_files_event(window)
+        assert refused.request_id == "open-2"
+        assert refused.status is SelectedFilesStatus.UNAVAILABLE
+        channel.send(
+            json.dumps(
+                {
+                    "type": "file_selector_result",
+                    "id": "open-1",
+                    "status": "cancelled",
+                }
+            )
+        )
+        await asyncio.sleep(0.05)
+        assert window.get_user_input_events().get_events() == []
+        window.request_selected_files(_file_request("open-3"))
+        await _wait_file_armed(window, "open-3")
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_browser_file_selector_result_reports_status() -> None:
     window = WebRTCClientWindow()
@@ -658,6 +749,7 @@ async def test_browser_script_checks_type_and_size_before_upload() -> None:
             "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`" in script
         )
         assert "input.multiple" in script
+        assert "file_selector_ack" in script
     finally:
         window.close()
 
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index dd20c5bea..2deb51696 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -14,7 +14,9 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
   clicks on the same button while a picker is open are ignored;
   **Open A then B** queues both selectors one at a time. Closing the native
   window or dropping the WebRTC tab completes leftover and in-flight picks
-  as unavailable.
+  as unavailable. A picker the host never shows within 300 seconds also
+  completes as unavailable; a picker that is shown stays open as long as the
+  user wants.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.

From a949fd5c1c3ac0957a4e0d2ee8cfaa76f24435bf Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 10:58:47 -0700
Subject: [PATCH 31/43] Harden file selection against stale timers and lost
 results

Cap the running upload total, keep file results across UI ticks that run no step, give each admitted pick its own timer token, and drop results from retired client generations. Note the deferred browser-handoff and macOS Tk cases.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/loop.py        |  9 +++-
 .../runtime_v2/file_selection_gate.py         | 44 +++++++++++--------
 .../runtime_v2/native_window_client_window.py | 17 +++++--
 .../flashdreams/runtime_v2/serving/web/app.js |  4 ++
 .../runtime_v2/serving/webrtc_server.py       |  9 ++++
 .../runtime_v2/webrtc_client_window.py        | 25 +++++------
 .../test_native_window_client_window.py       | 24 ++++++++++
 flashdreams/test_v2/test_selected_files.py    | 36 +++++++++++++--
 .../test_v2/test_webrtc_client_window.py      | 25 +++++++++++
 9 files changed, 154 insertions(+), 39 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index de7511402..cc43767f6 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -251,8 +251,15 @@ def _finish_run(
         """
         if step_completed:
             self.latest_result = result
+            self._pending_user_events.clear()
+        else:
+            # A file result arrives once, so keep it until a step can read it.
+            self._pending_user_events = [
+                event
+                for event in self._pending_user_events
+                if isinstance(event, SelectedFilesUserInputEvent)
+            ]
         self._step_index += 1
-        self._pending_user_events.clear()
 
     @final
     def _shutdown(self) -> None:
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
index 1811294e2..d5b8f1770 100644
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -136,23 +136,23 @@ def may_show(self, request_id: str, generation: int) -> bool:
             return self._is_active(request_id, generation) and not self._answered
 
     def expire_presentation(
-        self, request_id: str, generation: int
+        self, pending: QueuedFileSelection
     ) -> tuple[QueuedFileSelection, ...]:
         """Answer an unpresented request and every request waiting behind it.
 
         The active slot stays occupied until :meth:`complete` so the window
         does not open another picker while this host might still show one.
 
+        Args:
+            pending: The admitted request object, so a later pick that reuses
+                its id and generation does not match.
+
         Returns:
             Requests the window should answer as ``UNAVAILABLE``. Empty when
             the request is no longer current or the host already presented it.
         """
         with self._lock:
-            if (
-                not self._is_active(request_id, generation)
-                or self._presented
-                or self._answered
-            ):
+            if self._active is not pending or self._presented or self._answered:
                 return ()
             self._answered = True
             expired = [self._active, *self._queued]
@@ -196,6 +196,12 @@ def complete(
             self._active = nxt
             return deliver, nxt
 
+    @property
+    def generation(self) -> int:
+        """Client generation that new requests are stamped with."""
+        with self._lock:
+            return self._generation
+
     def is_current(self, request_id: str, generation: int) -> bool:
         """Return whether ``request_id`` is still the active selector for ``generation``."""
         with self._lock:
@@ -267,21 +273,16 @@ def __init__(
         self._on_expired = on_expired
         self._lock = threading.Lock()
         self._timer: threading.Timer | None = None
-        self._token: tuple[str, int] | None = None
+        self._token: QueuedFileSelection | None = None
 
     def arm(self, pending: QueuedFileSelection) -> None:
         """Start the presentation deadline for ``pending``."""
         self.cancel()
-        token = (pending.request_id, pending.generation)
-        timer = threading.Timer(
-            self._timeout_seconds,
-            self._fire,
-            args=token,
-        )
+        timer = threading.Timer(self._timeout_seconds, self._fire, args=(pending,))
         timer.daemon = True
         with self._lock:
             self._timer = timer
-            self._token = token
+            self._token = pending
         timer.start()
 
     def presented(self, request_id: str, generation: int) -> None:
@@ -304,7 +305,12 @@ def cancel(self) -> None:
 
     def _cancel_if(self, request_id: str, generation: int) -> None:
         with self._lock:
-            if self._token != (request_id, generation):
+            token = self._token
+            if (
+                token is None
+                or token.request_id != request_id
+                or token.generation != generation
+            ):
                 return
             timer = self._timer
             self._timer = None
@@ -312,18 +318,18 @@ def _cancel_if(self, request_id: str, generation: int) -> None:
         if timer is not None:
             timer.cancel()
 
-    def _fire(self, request_id: str, generation: int) -> None:
+    def _fire(self, pending: QueuedFileSelection) -> None:
         with self._lock:
-            if self._token != (request_id, generation):
+            if self._token is not pending:
                 return
             self._timer = None
             self._token = None
-        expired = self._gate.expire_presentation(request_id, generation)
+        expired = self._gate.expire_presentation(pending)
         if not expired:
             return
         _LOGGER.warning(
             "File selector %r was not presented within %g seconds.",
-            request_id,
+            pending.request_id,
             self._timeout_seconds,
         )
         self._on_expired(expired)
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 3ac69466f..f7959a421 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -227,6 +227,9 @@ def _ask_open_filename_tkinter(
     on_presented: Callable[[], None] | None = None,
 ) -> tuple[str, ...]:
     """Open the Tk file dialog (native Explorer / macOS panel)."""
+    # ponytail: this runs on a worker thread, which macOS may abort for Tk.
+    # Upgrade path: launch ``osascript`` "choose file" through
+    # ``_run_desktop_chooser`` as Linux does.
     import tkinter as tk
     from tkinter import filedialog
 
@@ -452,7 +455,7 @@ def request_selected_files(self, request: FileSelectionRequest) -> None:
         if admission.unavailable:
             self._enqueue_selected_files(
                 request.request_id,
-                generation=0,
+                generation=self._file_gate.generation,
                 status=SelectedFilesStatus.UNAVAILABLE,
             )
             return
@@ -770,10 +773,18 @@ def _enqueue_selected_files(
         status: SelectedFilesStatus,
         files: tuple[SelectedFile, ...] = (),
     ) -> None:
-        """Queue one selected-files event from any thread."""
+        """Queue one selected-files event from any thread.
+
+        A result from a retired client generation is dropped. ``open`` drains
+        the gate before it replaces the queue, so reading the queue first makes
+        a stale result land only in the discarded queue.
+        """
+        input_events = self._input_events
+        if generation != self._file_gate.generation:
+            return
         started_ns = self._session_started_ns
         elapsed_ns = 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
-        self._input_events.put(
+        input_events.put(
             SelectedFilesUserInputEvent(
                 timestamp=uint64(elapsed_ns // 1_000),
                 request_id=request_id,
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index f790ba91c..8cfbccfdd 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -335,6 +335,10 @@ const openFileSelector = options => {
   if (typeof requestId !== "string" || !requestId) {
     return;
   }
+  // ponytail: replies carry only the request id, so a prompt left open across a
+  // session handoff can answer the next session's request for the same id.
+  // Upgrade path: echo the server's generation in replies and replace the old
+  // prompt when a newer generation arrives.
   if (pendingFileRequest !== null) {
     if (
       pendingFileRequest.id !== requestId
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index c982b1e2a..3f95911a0 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -1114,6 +1114,7 @@ def emit(
                 emit(SelectedFilesStatus.TOO_LARGE)
                 raise
             chosen: list[tuple[str, bytes]] = []
+            total_bytes = 0
             while True:
                 part = await reader.next()
                 if part is None:
@@ -1139,6 +1140,14 @@ def emit(
                         max_size=policy.max_bytes,
                         actual_size=policy.max_bytes + 1,
                     )
+                total_bytes += len(data)
+                if total_bytes > MAX_SELECTED_FILE_BATCH_BYTES:
+                    emit(SelectedFilesStatus.TOO_LARGE)
+                    await _drain_multipart_reader(reader)
+                    raise web.HTTPRequestEntityTooLarge(
+                        max_size=MAX_SELECTED_FILE_BATCH_BYTES,
+                        actual_size=total_bytes,
+                    )
                 chosen.append((name, data))
             if not chosen:
                 emit(SelectedFilesStatus.UNAVAILABLE)
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index c2b5a80d6..5adaddccb 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -152,7 +152,9 @@ def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the connected browser to open a file selector."""
         admission = self._file_gate.submit(QueuedFileSelection.from_request(request))
         if admission.unavailable:
-            self._append_unavailable(request.request_id, generation=0)
+            self._append_unavailable(
+                request.request_id, generation=self._file_gate.generation
+            )
             return
         if admission.started is not None:
             self._start_file_selection(admission.started)
@@ -168,17 +170,8 @@ def _on_file_selection_unpresented(
         """
         if not expired:
             return
-        timestamp = self.server.event_timestamp_us()
-        with self._input_lock:
-            for item in expired:
-                self._input_events.append(
-                    SelectedFilesUserInputEvent(
-                        timestamp=timestamp,
-                        request_id=item.request_id,
-                        status=SelectedFilesStatus.UNAVAILABLE,
-                        _generation=item.generation,
-                    )
-                )
+        for item in expired:
+            self._append_unavailable(item.request_id, generation=item.generation)
         active = expired[0]
         if not self.server.drop_unsent_file_selector(
             active.request_id, active.generation
@@ -190,9 +183,15 @@ def _on_file_selection_unpresented(
             self._start_file_selection(nxt)
 
     def _append_unavailable(self, request_id: str, *, generation: int) -> None:
-        """Queue one unavailable file-selector result."""
+        """Queue one unavailable file-selector result for a current generation.
+
+        ``open`` drains the gate before it clears the queue under the same lock,
+        so checking the generation under that lock drops a retired result.
+        """
         timestamp = self.server.event_timestamp_us()
         with self._input_lock:
+            if generation != self._file_gate.generation:
+                return
             self._input_events.append(
                 SelectedFilesUserInputEvent(
                     timestamp=timestamp,
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index dbbc96290..f2dea2695 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -1232,6 +1232,30 @@ def picker(
     assert resumed[0].status is SelectedFilesStatus.CANCELLED
 
 
+def test_native_window_drops_a_result_from_a_retired_session() -> None:
+    presenter = _Presenter()
+    window = NativeWindowClientWindow(presenter_factory=_presenter_factory(presenter))
+    window.open(_session_desc())
+    retired = window._file_gate.generation
+    window.open(_session_desc())
+    window._enqueue_selected_files(
+        "open-1", generation=retired, status=SelectedFilesStatus.UNAVAILABLE
+    )
+    window._enqueue_selected_files(
+        "open-2",
+        generation=window._file_gate.generation,
+        status=SelectedFilesStatus.UNAVAILABLE,
+    )
+    events = window.get_user_input_events().get_events()
+    window.close()
+
+    assert [
+        event.request_id
+        for event in events
+        if isinstance(event, SelectedFilesUserInputEvent)
+    ] == ["open-2"]
+
+
 def test_native_window_presented_picker_waits_past_the_deadline(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 30ed9cc1a..16dccce94 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -119,6 +119,24 @@ def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
     ]
 
 
+def test_ui_loop_keeps_file_results_until_a_step_runs() -> None:
+    loop = _ui_loop()
+    picked = SelectedFilesUserInputEvent(
+        timestamp=uint64(0),
+        request_id="open-1",
+        status=SelectedFilesStatus.CANCELLED,
+    )
+
+    loop._begin_run(UserInputEvents([picked]), generation=0)
+    loop._finish_run(None, step_completed=False)
+    loop._begin_run(UserInputEvents([]), generation=0)
+    assert loop.user_events.get_events() == [picked]
+
+    loop._finish_run([], step_completed=True)
+    loop._begin_run(UserInputEvents([]), generation=0)
+    assert loop.user_events.get_events() == []
+
+
 def _queued(request_id: str) -> QueuedFileSelection:
     return QueuedFileSelection(
         request_id=request_id,
@@ -181,14 +199,14 @@ def test_file_selection_gate_holds_unpresented_request_until_host_finishes() ->
     active = gate.submit(_queued("open-1")).started
     assert active is not None
     assert gate.submit(_queued("open-2")).started is None
-    expired = gate.expire_presentation(active.request_id, active.generation)
+    expired = gate.expire_presentation(active)
     assert [item.request_id for item in expired] == ["open-1", "open-2"]
     assert gate.may_show(active.request_id, active.generation) is False
     assert gate.is_current(active.request_id, active.generation)
     refused = gate.submit(_queued("open-3"))
     assert refused.started is None
     assert refused.unavailable
-    assert gate.expire_presentation(active.request_id, active.generation) == ()
+    assert gate.expire_presentation(active) == ()
     assert gate.complete(active.request_id, active.generation) == (False, None)
     assert gate.submit(_queued("open-3")).started is not None
 
@@ -198,10 +216,22 @@ def test_file_selection_gate_presented_request_does_not_expire() -> None:
     active = gate.submit(_queued("open-1")).started
     assert active is not None
     assert gate.mark_presented(active.request_id, active.generation)
-    assert gate.expire_presentation(active.request_id, active.generation) == ()
+    assert gate.expire_presentation(active) == ()
     assert gate.complete(active.request_id, active.generation) == (True, None)
 
 
+def test_file_selection_gate_old_pick_cannot_expire_a_reused_id() -> None:
+    gate = FileSelectionGate()
+    old = gate.submit(_queued("open-1")).started
+    assert old is not None
+    assert gate.complete(old.request_id, old.generation) == (True, None)
+    new = gate.submit(_queued("open-1")).started
+    assert new is not None
+    assert (new.request_id, new.generation) == (old.request_id, old.generation)
+    assert gate.expire_presentation(old) == ()
+    assert gate.expire_presentation(new) == (new,)
+
+
 def test_selected_file_policy_helpers() -> None:
     assert clamp_selected_file_max_bytes(None) == MAX_SELECTED_FILE_BYTES
     assert clamp_selected_file_max_bytes(16) == 16
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index d0c3c503c..c4352e629 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -517,6 +517,31 @@ async def test_file_upload_rejects_oversize() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_file_upload_stops_once_the_batch_exceeds_its_cap(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(webrtc_server, "MAX_SELECTED_FILE_BATCH_BYTES", 5)
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(_file_request("open-1", multiple=True))
+        await _wait_file_armed(window, "open-1")
+        form = FormData()
+        for name in ("a.bin", "b.bin", "c.bin"):
+            form.add_field(
+                "file", b"xyz", filename=name, content_type="application/octet-stream"
+            )
+        async with ClientSession() as client:
+            async with client.post(_files_url(window, "open-1"), data=form) as response:
+                assert response.status == 413
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.TOO_LARGE
+        assert event.files == ()
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_file_upload_decodes_base64_transfer_encoding() -> None:
     window = WebRTCClientWindow()

From bf7c44adf606bf6a2c87b9d6a419fa3baa3c2699 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 11:25:24 -0700
Subject: [PATCH 32/43] Keep file results across disconnects and report types
 before batch size

Only a session replacement retires file results, so a viewer disconnect racing a timeout still answers the request. Over the batch cap, keep reading part names so a disallowed type is still reported first.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 .../runtime_v2/native_window_client_window.py | 13 +++--
 .../runtime_v2/serving/webrtc_server.py       | 33 ++++++------
 .../runtime_v2/webrtc_client_window.py        | 12 +++--
 .../test_v2/test_webrtc_client_window.py      | 51 +++++++++++++++++++
 4 files changed, 85 insertions(+), 24 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index f7959a421..f807b2052 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -400,6 +400,7 @@ def __init__(
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._file_gate = FileSelectionGate()
+        self._session_file_generation = 0
         self._presentation = FileSelectionPresentationTimer(
             self._file_gate,
             timeout_seconds=presentation_timeout_seconds,
@@ -585,6 +586,7 @@ def open(self, session_desc: SessionDesc) -> None:
                 raise
 
         self._invalidate_file_selections(deliver_unavailable=False)
+        self._session_file_generation = self._file_gate.generation
         self._session_started_ns = self._clock_ns()
         self._session_desc = session_desc
         self._window_size = presenter.size
@@ -668,6 +670,7 @@ def write(self, result: StepResult) -> None:
     def close(self) -> None:
         """Release SlangPy and the GLFW window on the runtime's UI thread."""
         self._invalidate_file_selections(deliver_unavailable=False)
+        self._session_file_generation = self._file_gate.generation
         presenter = self._presenter
         self._presenter = None
         self._session_started_ns = None
@@ -775,12 +778,14 @@ def _enqueue_selected_files(
     ) -> None:
         """Queue one selected-files event from any thread.
 
-        A result from a retired client generation is dropped. ``open`` drains
-        the gate before it replaces the queue, so reading the queue first makes
-        a stale result land only in the discarded queue.
+        A result from an ended session is dropped. ``open`` drains the gate and
+        records the new session's first generation before it replaces the
+        queue, so reading the queue first makes a stale result land only in the
+        discarded queue. A user closing the window also drains the gate, but
+        its results are still delivered with the close event.
         """
         input_events = self._input_events
-        if generation != self._file_gate.generation:
+        if generation < self._session_file_generation:
             return
         started_ns = self._session_started_ns
         elapsed_ns = 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 3f95911a0..5f48e8b91 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -1115,6 +1115,7 @@ def emit(
                 raise
             chosen: list[tuple[str, bytes]] = []
             total_bytes = 0
+            too_large = False
             while True:
                 part = await reader.next()
                 if part is None:
@@ -1124,7 +1125,7 @@ def emit(
                 if part.name != "file":
                     await part.release()
                     continue
-                if not policy.multiple and chosen:
+                if not policy.multiple and (chosen or too_large):
                     await part.release()
                     continue
                 name = part.filename or "upload"
@@ -1132,23 +1133,23 @@ def emit(
                     emit(SelectedFilesStatus.DISALLOWED_TYPE)
                     await _drain_multipart_reader(reader, part)
                     return web.Response(status=204)
+                if too_large:
+                    # Keep reading names so a disallowed type still wins.
+                    await part.release()
+                    continue
                 data = await _read_upload_part_bounded(part, max_bytes=policy.max_bytes)
-                if data is None:
-                    emit(SelectedFilesStatus.TOO_LARGE)
-                    await _drain_multipart_reader(reader)
-                    raise web.HTTPRequestEntityTooLarge(
-                        max_size=policy.max_bytes,
-                        actual_size=policy.max_bytes + 1,
-                    )
-                total_bytes += len(data)
-                if total_bytes > MAX_SELECTED_FILE_BATCH_BYTES:
-                    emit(SelectedFilesStatus.TOO_LARGE)
-                    await _drain_multipart_reader(reader)
-                    raise web.HTTPRequestEntityTooLarge(
-                        max_size=MAX_SELECTED_FILE_BATCH_BYTES,
-                        actual_size=total_bytes,
-                    )
+                if data is not None:
+                    total_bytes += len(data)
+                if data is None or total_bytes > MAX_SELECTED_FILE_BATCH_BYTES:
+                    too_large = True
+                    chosen.clear()
+                    continue
                 chosen.append((name, data))
+            if too_large:
+                emit(SelectedFilesStatus.TOO_LARGE)
+                raise web.HTTPRequestEntityTooLarge(
+                    max_size=policy.max_bytes, actual_size=policy.max_bytes + 1
+                )
             if not chosen:
                 emit(SelectedFilesStatus.UNAVAILABLE)
                 raise web.HTTPBadRequest(reason="File upload requires a file.")
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 5adaddccb..412d01ec0 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -85,6 +85,7 @@ def __init__(
             on_expired=self._on_file_selection_unpresented,
         )
         self._input_lock = threading.Lock()
+        self._session_file_generation = 0
         # Offset from the server's stable clock to the current session's clock.
         self._session_event_offset_us = uint64(0)
         self.server = WebRTCServer(
@@ -183,14 +184,16 @@ def _on_file_selection_unpresented(
             self._start_file_selection(nxt)
 
     def _append_unavailable(self, request_id: str, *, generation: int) -> None:
-        """Queue one unavailable file-selector result for a current generation.
+        """Queue one unavailable file-selector result unless its session ended.
 
-        ``open`` drains the gate before it clears the queue under the same lock,
-        so checking the generation under that lock drops a retired result.
+        ``open`` drains the gate, then records the new session's first
+        generation and clears the queue under the same lock. A viewer
+        disconnect also drains the gate but keeps the session, so its results
+        are still delivered.
         """
         timestamp = self.server.event_timestamp_us()
         with self._input_lock:
-            if generation != self._file_gate.generation:
+            if generation < self._session_file_generation:
                 return
             self._input_events.append(
                 SelectedFilesUserInputEvent(
@@ -241,6 +244,7 @@ def open(self, session_desc: SessionDesc) -> None:
         session_event_offset_us = self.server.event_timestamp_us()
         with self._input_lock:
             self._input_events.clear()
+            self._session_file_generation = self._file_gate.generation
             self._session_event_offset_us = session_event_offset_us
 
     def get_user_input_events(self) -> UserInputEvents:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index c4352e629..07b0796d8 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -542,6 +542,32 @@ async def test_file_upload_stops_once_the_batch_exceeds_its_cap(
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_file_upload_over_the_batch_cap_still_reports_a_disallowed_type(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(webrtc_server, "MAX_SELECTED_FILE_BATCH_BYTES", 5)
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(
+            _file_request("open-1", accept=(".bin",), multiple=True)
+        )
+        await _wait_file_armed(window, "open-1")
+        form = FormData()
+        for name in ("a.bin", "b.bin", "c.exe"):
+            form.add_field(
+                "file", b"xyz", filename=name, content_type="application/octet-stream"
+            )
+        async with ClientSession() as client:
+            async with client.post(_files_url(window, "open-1"), data=form) as response:
+                assert response.status == 204
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.DISALLOWED_TYPE
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_file_upload_decodes_base64_transfer_encoding() -> None:
     window = WebRTCClientWindow()
@@ -611,6 +637,31 @@ async def test_unsent_file_selector_times_out_and_releases_the_slot() -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_timeout_racing_a_disconnect_still_answers_the_request() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        window.request_selected_files(_file_request("open-1"))
+        window.request_selected_files(_file_request("open-2"))
+        active = window._file_gate._active
+        assert active is not None
+        expired = window._file_gate.expire_presentation(active)
+        window._invalidate_file_selections(True)
+        window._on_file_selection_unpresented(expired)
+        events = window.get_user_input_events().get_events()
+        assert [
+            (event.request_id, event.status)
+            for event in events
+            if isinstance(event, SelectedFilesUserInputEvent)
+        ] == [
+            ("open-1", SelectedFilesStatus.UNAVAILABLE),
+            ("open-2", SelectedFilesStatus.UNAVAILABLE),
+        ]
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_acknowledged_file_selector_waits_past_the_deadline() -> None:
     window = WebRTCClientWindow(presentation_timeout_seconds=0.3)

From 7616e5e2c43b49f0fa5a5dfe331f94342aec5f4b Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 12:29:56 -0700
Subject: [PATCH 33/43] Shorten the file picker presentation deadline to 30
 seconds

The deadline only covers the gap before the host shows a picker, which normally takes well under a second; browsing time has no deadline.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md                  | 2 +-
 flashdreams/flashdreams/runtime_v2/file_selection_gate.py | 2 +-
 integrations_v2/imgui_ui_demo/README.md                   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 4a79c36c4..76194da71 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -236,7 +236,7 @@ one. Using an id twice in one tick raises `ValueError`. `accept` is filename suf
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
 `runtime_v2/selected_file.py`. The status is `UNAVAILABLE` when the client
-cannot show a picker, or does not show one within 300 seconds. Once a picker
+cannot show a picker, or does not show one within 30 seconds. Once a picker
 is shown, the user may take as long as they want.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
index d5b8f1770..124d716af 100644
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
@@ -15,7 +15,7 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS = 300.0
+FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS = 30.0
 """Seconds to wait for the host to show a picker before answering ``UNAVAILABLE``.
 
 The deadline starts when a request is handed to the host. After the host reports
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index 2deb51696..c94a1797e 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -14,7 +14,7 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
   clicks on the same button while a picker is open are ignored;
   **Open A then B** queues both selectors one at a time. Closing the native
   window or dropping the WebRTC tab completes leftover and in-flight picks
-  as unavailable. A picker the host never shows within 300 seconds also
+  as unavailable. A picker the host never shows within 30 seconds also
   completes as unavailable; a picker that is shown stays open as long as the
   user wants.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.

From 535249034f690bbfaf6f3a79b693b6929617f24a Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 12:53:42 -0700
Subject: [PATCH 34/43] Keep filename spaces and keep prompt keys out of the
 app

Strip only the chooser's final newline so trailing spaces stay in a Linux filename. Do not forward key presses to the app while the browser prompt is open, including the Escape that cancels it. Note the deferred overlapping-dialog case on native session replacement.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 .../runtime_v2/native_window_client_window.py |  5 ++++-
 .../flashdreams/runtime_v2/serving/web/app.js |  3 ++-
 .../test_native_window_client_window.py       | 20 +++++++++++++++++++
 .../test_v2/test_webrtc_client_window.py      |  2 ++
 4 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index f807b2052..4baec73ca 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -200,7 +200,7 @@ def _parse_chooser_stdout(
     """Return selected paths from a chooser, or ``()`` when cancelled."""
     if completed.returncode == 1:
         return ()
-    output = completed.stdout.strip()
+    output = completed.stdout.removesuffix("\n")
     if not output:
         return ()
     if not multiple:
@@ -585,6 +585,9 @@ def open(self, session_desc: SessionDesc) -> None:
                 presenter.close()
                 raise
 
+        # ponytail: this frees the picker slot while an old OS dialog may still be
+        # open, so the replacement session can open a second dialog beside it.
+        # Upgrade path: keep the drained slot occupied until its worker finishes.
         self._invalidate_file_selections(deliver_unavailable=False)
         self._session_file_generation = self._file_gate.generation
         self._session_started_ns = self._clock_ns()
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 8cfbccfdd..0bf11bc33 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -202,6 +202,7 @@ window.addEventListener("keydown", event => {
     return;
   }
   event.preventDefault();
+  event.stopImmediatePropagation();
   promptDialogCancel?.click();
 });
 
@@ -444,7 +445,7 @@ peer.addEventListener("connectionstatechange", () => {
 
 window.addEventListener("keydown", event => {
   const keyId = event.code || event.key;
-  if (pressedKeys.has(keyId)) {
+  if (pressedKeys.has(keyId) || (promptDialog !== null && promptDialog.open)) {
     return;
   }
   const wasSent = sendInput({
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index f2dea2695..ea75d1c7d 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -1071,6 +1071,26 @@ def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
     assert "--file-filter=Accepted | *.png *.jpg" in calls[1]
 
 
+def test_ask_open_filename_linux_keeps_trailing_spaces_in_a_filename(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        native_window_module.shutil,
+        "which",
+        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
+    )
+    monkeypatch.setattr(
+        native_window_module.subprocess,
+        "Popen",
+        lambda argv, **kwargs: _ChooserProcess(
+            returncode=0, stdout="/tmp/report.bin \n"
+        ),
+    )
+    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == (
+        "/tmp/report.bin ",
+    )
+
+
 def test_ask_open_filename_linux_cancel_is_empty(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 07b0796d8..be9eaa77c 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -826,6 +826,8 @@ async def test_browser_script_checks_type_and_size_before_upload() -> None:
         )
         assert "input.multiple" in script
         assert "file_selector_ack" in script
+        assert "event.stopImmediatePropagation();" in script
+        assert "(promptDialog !== null && promptDialog.open)" in script
     finally:
         window.close()
 

From aed4a5fe0d31125a9d444177a8e32b01e799ff16 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 16:09:55 -0700
Subject: [PATCH 35/43] Simplify file selection to one picker per session

Move the file-selection rules into the session runner: one picker in
flight, a 30 s deadline that stops once the window reports the picker
opened, and dropping results for any other id. A request made while
another picker is open completes as UNAVAILABLE; a repeat for the open
id is ignored.

Windows now only show a picker and report back. The native window uses
Tk on every platform. The WebRTC server keeps only armed upload policy
and its upload validation. Remove the file-selection gate, the
presentation timer, generation tracking, and the browser queue.

The file-picker demo shows one status line per button.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |   7 +-
 .../flashdreams/api_v2/client_window.py       |   9 +-
 flashdreams/flashdreams/api_v2/loop.py        |   5 +-
 .../runtime_v2/file_selection_gate.py         | 335 -----------
 .../runtime_v2/native_window_client_window.py | 383 ++----------
 .../flashdreams/runtime_v2/selected_file.py   |  10 +-
 .../flashdreams/runtime_v2/serving/web/app.js |  17 +-
 .../runtime_v2/serving/webrtc_server.py       | 350 ++---------
 .../flashdreams/runtime_v2/session_runner.py  | 114 +++-
 .../runtime_v2/user_input_event.py            |  20 +-
 .../runtime_v2/webrtc_client_window.py        | 141 +----
 .../test_native_window_client_window.py       | 558 +-----------------
 flashdreams/test_v2/test_selected_files.py    | 186 +++---
 .../test_v2/test_webrtc_client_window.py      | 305 ++--------
 integrations_v2/imgui_ui_demo/README.md       |  22 +-
 .../imgui_ui_demo/file_picker_app.py          | 117 ++--
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |  66 ++-
 17 files changed, 529 insertions(+), 2116 deletions(-)
 delete mode 100644 flashdreams/flashdreams/runtime_v2/file_selection_gate.py

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 76194da71..a57ff7592 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -235,9 +235,10 @@ one. Using an id twice in one tick raises `ValueError`. `accept` is filename suf
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
-`runtime_v2/selected_file.py`. The status is `UNAVAILABLE` when the client
-cannot show a picker, or does not show one within 30 seconds. Once a picker
-is shown, the user may take as long as they want.
+`runtime_v2/selected_file.py`. One picker is open at a time; a request made
+while another is open completes as `UNAVAILABLE`. The status is also
+`UNAVAILABLE` when the client cannot show a picker, or does not show one within
+30 seconds. Once a picker is shown, the user may take as long as they want.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 933da1c6c..dbbe79cdc 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -66,10 +66,11 @@ def request_selected_files(
         :meth:`InputSource.get_user_input_events`. The default has no
         selector and returns ``UNAVAILABLE``.
 
-        Do not block. Answer ``UNAVAILABLE`` when the host rejects the request,
-        fails, or does not show a picker within a bounded time. Once a picker
-        is shown, wait for the user without a deadline, and never close that
-        picker from here.
+        Do not block. Deliver a ``FileSelectorOpenedUserInputEvent`` once the
+        picker is shown, then the result when the user finishes. The runtime
+        sends one request at a time and answers ``UNAVAILABLE`` itself if the
+        picker is not shown in time. Answer ``UNAVAILABLE`` when the host
+        cannot show a picker.
 
         Args:
             request: Selector request queued by the UI loop.
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index cc43767f6..8cb9e397a 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -557,8 +557,9 @@ def file_selector(
         Call every UI tick from each place in the UI that can open a picker.
         Pass ``open=True`` only on the tick that the user asks to open it, such
         as when an ImGui button returns ``True``. Use a different stable
-        ``request_id`` for each such place. While a pick for ``request_id`` is
-        still open, another ``open=True`` for it is dropped with a warning.
+        ``request_id`` for each such place. One picker is open at a time:
+        another ``open=True`` for the open ``request_id`` is ignored, and one
+        for any other id completes as ``UNAVAILABLE``.
 
         Example:
 
diff --git a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py b/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
deleted file mode 100644
index 124d716af..000000000
--- a/flashdreams/flashdreams/runtime_v2/file_selection_gate.py
+++ /dev/null
@@ -1,335 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-"""One-at-a-time client file-selector queue shared by every window."""
-
-from __future__ import annotations
-
-import logging
-import threading
-from collections import deque
-from collections.abc import Callable
-from dataclasses import dataclass, replace
-
-from flashdreams.runtime_v2.selected_file import FileSelectionRequest
-
-_LOGGER = logging.getLogger(__name__)
-
-FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS = 30.0
-"""Seconds to wait for the host to show a picker before answering ``UNAVAILABLE``.
-
-The deadline starts when a request is handed to the host. After the host reports
-that the picker is presented, the user may take as long as they want. The
-deadline does not close a picker that is already open.
-"""
-
-
-@dataclass(frozen=True, slots=True)
-class QueuedFileSelection:
-    """One file-selector request waiting to become active."""
-
-    request_id: str
-    """Stable id for which button this request is for."""
-
-    initial_path: str | None
-    """Directory hint for the selector, or ``None`` for the window default."""
-
-    accept: tuple[str, ...]
-    """Filename suffixes the client may choose, empty for any type."""
-
-    max_bytes: int | None
-    """Requested size budget in bytes, or ``None`` for the window ceiling."""
-
-    multiple: bool = False
-    """Whether the selector may return more than one file."""
-
-    generation: int = 0
-    """Client generation that admitted this request. Stale pickers do not match."""
-
-    @classmethod
-    def from_request(cls, request: FileSelectionRequest) -> QueuedFileSelection:
-        """Build a queued selection from a UI-loop request."""
-        return cls(
-            request_id=request.request_id,
-            initial_path=request.initial_path,
-            accept=request.accept,
-            max_bytes=request.max_bytes,
-            multiple=request.multiple,
-        )
-
-
-@dataclass(frozen=True, slots=True)
-class FileSelectionAdmission:
-    """What the window should do with one submitted file-selector request."""
-
-    started: QueuedFileSelection | None = None
-    """Request to hand to the host now, or ``None`` when it is not starting."""
-
-    unavailable: bool = False
-    """Answer this submit with ``UNAVAILABLE`` and do not open another picker."""
-
-
-class FileSelectionGate:
-    """Run one file picker at a time; later requests wait in a queue.
-
-    - A repeated ``request_id`` is ignored.
-    - :meth:`complete` frees the slot and says whether to deliver the result.
-    - :meth:`expire_presentation` answers a picker that never appeared, but
-      keeps the slot until the host finishes, so two pickers never overlap.
-    - :meth:`drain` drops everything, so late results cannot match new requests.
-    """
-
-    def __init__(self) -> None:
-        """Create an empty gate."""
-        self._lock = threading.Lock()
-        self._active: QueuedFileSelection | None = None
-        self._queued: deque[QueuedFileSelection] = deque()
-        self._generation = 0
-        self._presented = False
-        self._answered = False
-
-    def submit(self, pending: QueuedFileSelection) -> FileSelectionAdmission:
-        """Record ``pending`` and return whether it should start now.
-
-        Args:
-            pending: Request the window wants to show.
-
-        Returns:
-            An admission whose ``started`` request is handed to the host when
-            no selector is active. ``unavailable`` is set when a previous
-            picker was already answered but the host has not finished.
-            Otherwise the request was queued or ignored as a duplicate.
-        """
-        with self._lock:
-            if self._contains(pending.request_id):
-                _LOGGER.warning(
-                    "Ignoring duplicate file-selection request id %r.",
-                    pending.request_id,
-                )
-                return FileSelectionAdmission()
-            if self._active is not None and self._answered:
-                return FileSelectionAdmission(unavailable=True)
-            stamped = replace(pending, generation=self._generation)
-            if self._active is None:
-                self._active = stamped
-                self._presented = False
-                self._answered = False
-                return FileSelectionAdmission(started=stamped)
-            self._queued.append(stamped)
-            return FileSelectionAdmission()
-
-    def mark_presented(self, request_id: str, generation: int) -> bool:
-        """Record that the host showed ``request_id``.
-
-        Returns:
-            ``True`` when this request is still waiting for that signal.
-        """
-        with self._lock:
-            if not self._is_active(request_id, generation) or self._answered:
-                return False
-            self._presented = True
-            return True
-
-    def may_show(self, request_id: str, generation: int) -> bool:
-        """Return whether the host should still be asked to show this request."""
-        with self._lock:
-            return self._is_active(request_id, generation) and not self._answered
-
-    def expire_presentation(
-        self, pending: QueuedFileSelection
-    ) -> tuple[QueuedFileSelection, ...]:
-        """Answer an unpresented request and every request waiting behind it.
-
-        The active slot stays occupied until :meth:`complete` so the window
-        does not open another picker while this host might still show one.
-
-        Args:
-            pending: The admitted request object, so a later pick that reuses
-                its id and generation does not match.
-
-        Returns:
-            Requests the window should answer as ``UNAVAILABLE``. Empty when
-            the request is no longer current or the host already presented it.
-        """
-        with self._lock:
-            if self._active is not pending or self._presented or self._answered:
-                return ()
-            self._answered = True
-            expired = [self._active, *self._queued]
-            self._queued.clear()
-            return tuple(item for item in expired if item is not None)
-
-    def complete(
-        self, request_id: str, generation: int | None = None
-    ) -> tuple[bool, QueuedFileSelection | None]:
-        """Release ``request_id`` if it is still current and return the next start.
-
-        Callers emit the host result only when this returns ``deliver=True``.
-        A request already answered by :meth:`expire_presentation` still releases
-        the slot, but its host result is not delivered. Client-gone
-        :meth:`drain` wins the race against in-flight work.
-
-        Args:
-            request_id: Id of the in-flight selector.
-            generation: Client generation of that selector, or ``None`` to
-                match only the id.
-
-        Returns:
-            ``(True, next)`` when the host result should be delivered.
-            ``next`` is the request that should start now, or ``None`` if the
-            queue is empty. ``(False, next)`` when the slot was released but
-            the app already has a result. ``(False, None)`` when the id is
-            not current.
-        """
-        with self._lock:
-            if self._active is None or self._active.request_id != request_id:
-                return False, None
-            if generation is not None and self._active.generation != generation:
-                return False, None
-            deliver = not self._answered
-            self._active = None
-            self._presented = False
-            self._answered = False
-            if not self._queued:
-                return deliver, None
-            nxt = self._queued.popleft()
-            self._active = nxt
-            return deliver, nxt
-
-    @property
-    def generation(self) -> int:
-        """Client generation that new requests are stamped with."""
-        with self._lock:
-            return self._generation
-
-    def is_current(self, request_id: str, generation: int) -> bool:
-        """Return whether ``request_id`` is still the active selector for ``generation``."""
-        with self._lock:
-            return (
-                self._active is not None
-                and self._active.request_id == request_id
-                and self._active.generation == generation
-            )
-
-    def drain(self) -> tuple[QueuedFileSelection, ...]:
-        """Return unanswered requests, then start a new client generation.
-
-        A request already answered by :meth:`expire_presentation` is dropped
-        here without being returned again.
-        """
-        with self._lock:
-            items: list[QueuedFileSelection] = []
-            if self._active is not None and not self._answered:
-                items.append(self._active)
-            items.extend(self._queued)
-            self._active = None
-            self._queued.clear()
-            self._presented = False
-            self._answered = False
-            self._generation += 1
-            return tuple(items)
-
-    def clear(self) -> None:
-        """Drop remaining requests and start a new client generation."""
-        self.drain()
-
-    def _contains(self, request_id: str) -> bool:
-        if self._active is not None and self._active.request_id == request_id:
-            return True
-        return any(item.request_id == request_id for item in self._queued)
-
-    def _is_active(self, request_id: str, generation: int) -> bool:
-        return (
-            self._active is not None
-            and self._active.request_id == request_id
-            and self._active.generation == generation
-        )
-
-
-class FileSelectionPresentationTimer:
-    """Fail one request when the host does not show its picker in time."""
-
-    def __init__(
-        self,
-        gate: FileSelectionGate,
-        *,
-        timeout_seconds: float,
-        on_expired: Callable[[tuple[QueuedFileSelection, ...]], None],
-    ) -> None:
-        """Arm deadlines against ``gate``.
-
-        Args:
-            gate: Queue whose active request this timer watches.
-            timeout_seconds: Presentation deadline. Must be positive.
-            on_expired: Called with the requests to answer as ``UNAVAILABLE``.
-
-        Raises:
-            ValueError: ``timeout_seconds`` is not positive.
-        """
-        if timeout_seconds <= 0:
-            raise ValueError("presentation_timeout_seconds must be > 0.")
-        self._gate = gate
-        self._timeout_seconds = timeout_seconds
-        self._on_expired = on_expired
-        self._lock = threading.Lock()
-        self._timer: threading.Timer | None = None
-        self._token: QueuedFileSelection | None = None
-
-    def arm(self, pending: QueuedFileSelection) -> None:
-        """Start the presentation deadline for ``pending``."""
-        self.cancel()
-        timer = threading.Timer(self._timeout_seconds, self._fire, args=(pending,))
-        timer.daemon = True
-        with self._lock:
-            self._timer = timer
-            self._token = pending
-        timer.start()
-
-    def presented(self, request_id: str, generation: int) -> None:
-        """Cancel the deadline when the host has shown this request."""
-        if self._gate.mark_presented(request_id, generation):
-            self._cancel_if(request_id, generation)
-
-    def finished(self, request_id: str, generation: int) -> None:
-        """Cancel the deadline because the host finished this request."""
-        self._cancel_if(request_id, generation)
-
-    def cancel(self) -> None:
-        """Cancel the current deadline, if one is armed."""
-        with self._lock:
-            timer = self._timer
-            self._timer = None
-            self._token = None
-        if timer is not None:
-            timer.cancel()
-
-    def _cancel_if(self, request_id: str, generation: int) -> None:
-        with self._lock:
-            token = self._token
-            if (
-                token is None
-                or token.request_id != request_id
-                or token.generation != generation
-            ):
-                return
-            timer = self._timer
-            self._timer = None
-            self._token = None
-        if timer is not None:
-            timer.cancel()
-
-    def _fire(self, pending: QueuedFileSelection) -> None:
-        with self._lock:
-            if self._token is not pending:
-                return
-            self._timer = None
-            self._token = None
-        expired = self._gate.expire_presentation(pending)
-        if not expired:
-            return
-        _LOGGER.warning(
-            "File selector %r was not presented within %g seconds.",
-            pending.request_id,
-            self._timeout_seconds,
-        )
-        self._on_expired(expired)
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 4baec73ca..819262b9a 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -7,10 +7,6 @@
 
 import logging
 import queue
-import shlex
-import shutil
-import subprocess
-import sys
 import threading
 import time
 from collections import deque
@@ -26,12 +22,6 @@
 
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.user_input_event import UserInputEvent
-from flashdreams.runtime_v2.file_selection_gate import (
-    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
-    FileSelectionGate,
-    FileSelectionPresentationTimer,
-    QueuedFileSelection,
-)
 from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BYTES,
     FileSelectionRequest,
@@ -44,6 +34,7 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
+    FileSelectorOpenedUserInputEvent,
     GamepadUserInputEvent,
     KeyboardInputState,
     KeyboardUserInputEvent,
@@ -66,170 +57,18 @@ def _ask_open_filename(
     multiple: bool = False,
     on_presented: Callable[[], None] | None = None,
 ) -> tuple[str, ...]:
-    """Return paths from the OS file picker, or an empty tuple when cancelled.
+    """Return paths from the Tk file dialog, or an empty tuple when cancelled.
 
-    ``on_presented`` runs once this process has handed the request to a running
-    chooser. It does not mean a remote host made that chooser visible.
+    Tk shows Explorer on Windows, the macOS panel, and its own dialog on Linux.
+    ``on_presented`` runs just before the dialog opens. It does not mean a
+    remote host made that dialog visible.
 
     Raises:
-        RuntimeError: The desktop chooser is missing or failed.
-    """
-    if sys.platform.startswith("linux"):
-        return _ask_open_filename_linux(
-            initial_dir=initial_dir,
-            accept=accept,
-            multiple=multiple,
-            on_presented=on_presented,
-        )
-    return _ask_open_filename_tkinter(
-        initial_dir=initial_dir,
-        accept=accept,
-        multiple=multiple,
-        on_presented=on_presented,
-    )
-
-
-def _accept_filter_patterns(accept: tuple[str, ...]) -> str:
-    """Return glob patterns for ``accept`` suffixes, such as ``*.png *.jpg``."""
-    return " ".join(f"*{suffix}" for suffix in accept)
-
-
-def _ask_open_filename_linux(
-    *,
-    initial_dir: str,
-    accept: tuple[str, ...] = (),
-    multiple: bool = False,
-    on_presented: Callable[[], None] | None = None,
-) -> tuple[str, ...]:
-    """Open the desktop file picker via ``zenity`` or ``kdialog``.
-
-    ``zenity --file-selection`` uses ``GtkFileChooserNative``, which is the
-    xdg-desktop-portal chooser. The helper is a separate process so the
-    GLFW window does not host GTK.
-    """
-    directory = str(Path(initial_dir))
-    patterns = _accept_filter_patterns(accept)
-    zenity = shutil.which("zenity")
-    if zenity is not None:
-        argv = [
-            zenity,
-            "--file-selection",
-            f"--filename={directory}/",
-            "--title=Select a file",
-        ]
-        if multiple:
-            # '/' cannot appear in a filename, so '//' joins two absolute
-            # paths. NUL cannot be passed in argv.
-            argv.extend(("--multiple", "--separator=/"))
-        if patterns:
-            argv.append(f"--file-filter=Accepted | {patterns}")
-        return _parse_chooser_stdout(
-            _run_desktop_chooser(argv, on_presented=on_presented),
-            multiple=multiple,
-            quoted=False,
-        )
-    kdialog = shutil.which("kdialog")
-    if kdialog is None:
-        raise RuntimeError(
-            "Native file picker needs a desktop chooser (zenity or kdialog)."
-        )
-    argv = [kdialog, "--getopenfilename"]
-    if multiple:
-        argv.append("--multiple")
-    argv.append(directory)
-    if patterns:
-        argv.append(f"Accepted ({patterns})")
-    return _parse_chooser_stdout(
-        _run_desktop_chooser(argv, on_presented=on_presented),
-        multiple=multiple,
-        quoted=True,
-    )
-
-
-def _run_desktop_chooser(
-    argv: list[str],
-    *,
-    on_presented: Callable[[], None] | None = None,
-) -> subprocess.CompletedProcess[str]:
-    """Run one desktop file chooser and map non-cancel failures to errors.
-
-    A process that is still running counts as presented. The chooser is not
-    killed if the caller later stops waiting for it.
+        ImportError: This Python was built without Tk.
+        tkinter.TclError: Tk cannot open a dialog, such as without a display.
     """
-    # ponytail: process start is the presentation signal. A host that launches
-    # the chooser and then hides it is indistinguishable from a user who has
-    # not finished. Upgrade path: IFileDialogEvents, NSOpenPanel visibility,
-    # or an XDG portal request handle.
-    try:
-        process = subprocess.Popen(
-            argv,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-    except OSError as exc:
-        raise RuntimeError("Native file picker failed to start.") from exc
-    if process.poll() is None and on_presented is not None:
-        on_presented()
-    stdout, stderr = process.communicate()
-    if process.returncode is None:
-        raise RuntimeError("Native file picker ended without a status.")
-    completed = subprocess.CompletedProcess(
-        argv,
-        process.returncode,
-        stdout or "",
-        stderr or "",
-    )
-    if completed.returncode == 1:
-        return completed
-    if completed.returncode != 0:
-        detail = (completed.stderr or completed.stdout or "").strip()
-        raise RuntimeError(
-            f"Native file picker failed with exit {completed.returncode}"
-            + (f": {detail}" if detail else ".")
-        )
-    return completed
-
-
-def _parse_chooser_stdout(
-    completed: subprocess.CompletedProcess[str],
-    *,
-    multiple: bool,
-    quoted: bool,
-) -> tuple[str, ...]:
-    """Return selected paths from a chooser, or ``()`` when cancelled."""
-    if completed.returncode == 1:
-        return ()
-    output = completed.stdout.removesuffix("\n")
-    if not output:
-        return ()
-    if not multiple:
-        return (output,)
-    if quoted:
-        return tuple(shlex.split(output))
-    return _split_zenity_absolute_paths(output)
-
-
-def _split_zenity_absolute_paths(output: str) -> tuple[str, ...]:
-    """Split zenity ``--separator=/`` stdout into absolute paths.
-
-    A newline inside a filename stays in that path.
-    """
-    head, *tail = output.split("//")
-    return (head, *(f"/{part}" for part in tail if part))
-
-
-def _ask_open_filename_tkinter(
-    *,
-    initial_dir: str,
-    accept: tuple[str, ...] = (),
-    multiple: bool = False,
-    on_presented: Callable[[], None] | None = None,
-) -> tuple[str, ...]:
-    """Open the Tk file dialog (native Explorer / macOS panel)."""
     # ponytail: this runs on a worker thread, which macOS may abort for Tk.
-    # Upgrade path: launch ``osascript`` "choose file" through
-    # ``_run_desktop_chooser`` as Linux does.
+    # Upgrade path: launch ``osascript`` "choose file" as a separate process.
     import tkinter as tk
     from tkinter import filedialog
 
@@ -240,7 +79,8 @@ def _ask_open_filename_tkinter(
     except tk.TclError:
         pass
     # ponytail: calling the Tk dialog is the presentation signal. Tk does not
-    # report when Explorer or the macOS panel is actually visible.
+    # report when the dialog is actually visible. Upgrade path:
+    # IFileDialogEvents on Windows or NSOpenPanel visibility on macOS.
     if on_presented is not None:
         on_presented()
     try:
@@ -249,7 +89,9 @@ def _ask_open_filename_tkinter(
             "title": "Select a file",
         }
         if accept:
-            kwargs["filetypes"] = [("Accepted", _accept_filter_patterns(accept))]
+            kwargs["filetypes"] = [
+                ("Accepted", " ".join(f"*{suffix}" for suffix in accept))
+            ]
         if multiple:
             selected = filedialog.askopenfilenames(**kwargs)
             return tuple(str(path) for path in selected if path)
@@ -363,9 +205,6 @@ def __init__(
         title: str = "FlashDreams",
         presenter_factory: Callable[..., _SlangPyNativeWindowPresenter] | None = None,
         clock_ns: Callable[[], int] = time.monotonic_ns,
-        presentation_timeout_seconds: float = (
-            FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
-        ),
     ) -> None:
         """Configure the native client window.
 
@@ -373,13 +212,9 @@ def __init__(
             title: Native window title.
             presenter_factory: Optional SlangPy-compatible presenter factory.
             clock_ns: Monotonic clock used for input timestamps.
-            presentation_timeout_seconds: How long to wait for the OS chooser
-                to start. After it starts, the user may take as long as they
-                want.
 
         Raises:
-            ValueError: ``title`` is empty or the presentation deadline is not
-                positive.
+            ValueError: ``title`` is empty.
         """
         if not title.strip():
             raise ValueError("Native-window title must be non-empty.")
@@ -399,13 +234,6 @@ def __init__(
         self._pressed_key_values: dict[str, str] = {}
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._file_gate = FileSelectionGate()
-        self._session_file_generation = 0
-        self._presentation = FileSelectionPresentationTimer(
-            self._file_gate,
-            timeout_seconds=presentation_timeout_seconds,
-            on_expired=self._on_file_selection_unpresented,
-        )
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the native window."""
@@ -445,112 +273,56 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         self._window_size = presenter.resize(*new_window_size)
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
-        """Ask the OS file selector and enqueue the chosen files."""
-        admission = self._file_gate.submit(
-            replace(
-                QueuedFileSelection.from_request(request),
-                initial_path=request.initial_path or str(Path.home()),
-                max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
-            )
-        )
-        if admission.unavailable:
-            self._enqueue_selected_files(
-                request.request_id,
-                generation=self._file_gate.generation,
-                status=SelectedFilesStatus.UNAVAILABLE,
-            )
-            return
-        if admission.started is not None:
-            self._spawn_file_picker(admission.started)
-
-    def _on_file_selection_unpresented(
-        self, expired: tuple[QueuedFileSelection, ...]
-    ) -> None:
-        """Answer requests whose chooser did not start in time."""
-        for item in expired:
-            self._enqueue_selected_files(
-                item.request_id,
-                generation=item.generation,
-                status=SelectedFilesStatus.UNAVAILABLE,
-            )
-
-    def _spawn_file_picker(self, pending: QueuedFileSelection) -> None:
-        """Run one OS picker on a worker thread."""
-        self._presentation.arm(pending)
-        worker = threading.Thread(
+        """Open the Tk file dialog on a worker thread so the window keeps presenting."""
+        threading.Thread(
             target=self._complete_file_selection,
-            args=(
-                pending.request_id,
-                pending.generation,
-                pending.initial_path or str(Path.home()),
-                pending.accept,
-                pending.max_bytes
-                if pending.max_bytes is not None
-                else MAX_SELECTED_FILE_BYTES,
-                pending.multiple,
-            ),
+            args=(request,),
             name="flashdreams-file-picker",
             daemon=True,
-        )
-        worker.start()
+        ).start()
 
-    def _complete_file_selection(
-        self,
-        request_id: str,
-        generation: int,
-        initial_dir: str,
-        accept: tuple[str, ...],
-        max_bytes: int,
-        multiple: bool,
-    ) -> None:
-        """Run the OS picker and enqueue a selected-files event."""
+    def _complete_file_selection(self, request: FileSelectionRequest) -> None:
+        """Run the file dialog, then queue ``opened`` and one result event."""
         files: tuple[SelectedFile, ...] = ()
         status = SelectedFilesStatus.UNAVAILABLE
         try:
-            try:
-                selected = _ask_open_filename(
-                    initial_dir=initial_dir,
-                    accept=accept,
-                    multiple=multiple,
-                    on_presented=lambda: self._presentation.presented(
-                        request_id, generation
-                    ),
-                )
-            except Exception:
-                _LOGGER.exception(
-                    "Native file picker failed for request id %r.",
-                    request_id,
-                )
-            else:
-                if selected:
-                    if not multiple:
-                        selected = selected[:1]
-                    files, status = _selected_files_from_paths(
-                        selected,
-                        accept=accept,
-                        max_bytes=max_bytes,
+            selected = _ask_open_filename(
+                initial_dir=request.initial_path or str(Path.home()),
+                accept=request.accept,
+                multiple=request.multiple,
+                on_presented=lambda: self._put_from_worker(
+                    FileSelectorOpenedUserInputEvent(
+                        timestamp=uint64(0), request_id=request.request_id
                     )
-                else:
-                    status = SelectedFilesStatus.CANCELLED
-        finally:
-            self._presentation.finished(request_id, generation)
-            claimed, nxt = self._file_gate.complete(request_id, generation)
-            if claimed:
-                self._enqueue_selected_files(
-                    request_id,
-                    generation=generation,
-                    status=status,
-                    files=files,
+                ),
+            )
+        except Exception:
+            _LOGGER.exception(
+                "Native file picker failed for request id %r.", request.request_id
+            )
+        else:
+            if selected:
+                files, status = _selected_files_from_paths(
+                    selected if request.multiple else selected[:1],
+                    accept=request.accept,
+                    max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
                 )
-            if nxt is not None and self._presenter is not None:
-                self._spawn_file_picker(nxt)
+            else:
+                status = SelectedFilesStatus.CANCELLED
+        self._put_from_worker(
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=request.request_id,
+                status=status,
+                files=files,
+            )
+        )
 
     def open(self, session_desc: SessionDesc) -> None:
         """Open a session in the GLFW window on the runtime's UI thread.
 
         Replacement sessions reuse the existing presenter and clear input
-        buffered for the completed session. Leftover and in-flight file picks
-        are dropped rather than delivered to the replacement.
+        buffered for the completed session.
 
         Args:
             session_desc: Resolved output dimensions and tensor layout.
@@ -585,11 +357,6 @@ def open(self, session_desc: SessionDesc) -> None:
                 presenter.close()
                 raise
 
-        # ponytail: this frees the picker slot while an old OS dialog may still be
-        # open, so the replacement session can open a second dialog beside it.
-        # Upgrade path: keep the drained slot occupied until its worker finishes.
-        self._invalidate_file_selections(deliver_unavailable=False)
-        self._session_file_generation = self._file_gate.generation
         self._session_started_ns = self._clock_ns()
         self._session_desc = session_desc
         self._window_size = presenter.size
@@ -672,8 +439,6 @@ def write(self, result: StepResult) -> None:
 
     def close(self) -> None:
         """Release SlangPy and the GLFW window on the runtime's UI thread."""
-        self._invalidate_file_selections(deliver_unavailable=False)
-        self._session_file_generation = self._file_gate.generation
         presenter = self._presenter
         self._presenter = None
         self._session_started_ns = None
@@ -768,55 +533,13 @@ def _on_window_closed(self) -> None:
         if self._close_event_enqueued:
             return
         self._close_event_enqueued = True
-        self._invalidate_file_selections(deliver_unavailable=True)
         self._put_input(CloseUserInputEvent(timestamp=uint64(0)))
 
-    def _enqueue_selected_files(
-        self,
-        request_id: str,
-        *,
-        generation: int,
-        status: SelectedFilesStatus,
-        files: tuple[SelectedFile, ...] = (),
-    ) -> None:
-        """Queue one selected-files event from any thread.
-
-        A result from an ended session is dropped. ``open`` drains the gate and
-        records the new session's first generation before it replaces the
-        queue, so reading the queue first makes a stale result land only in the
-        discarded queue. A user closing the window also drains the gate, but
-        its results are still delivered with the close event.
-        """
-        input_events = self._input_events
-        if generation < self._session_file_generation:
-            return
+    def _put_from_worker(self, event: UserInputEvent) -> None:
+        """Queue one event from a picker thread, bypassing the poll-time buffer."""
         started_ns = self._session_started_ns
         elapsed_ns = 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
-        input_events.put(
-            SelectedFilesUserInputEvent(
-                timestamp=uint64(elapsed_ns // 1_000),
-                request_id=request_id,
-                status=status,
-                files=files,
-                _generation=generation,
-            )
-        )
-
-    def _invalidate_file_selections(self, *, deliver_unavailable: bool) -> None:
-        """Finish this client generation; optionally report leftovers as unavailable."""
-        self._presentation.cancel()
-        leftover = self._file_gate.drain()
-        if not deliver_unavailable:
-            return
-        for item in leftover:
-            self._put_input(
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id=item.request_id,
-                    status=SelectedFilesStatus.UNAVAILABLE,
-                    _generation=item.generation,
-                )
-            )
+        self._input_events.put(replace(event, timestamp=uint64(elapsed_ns // 1_000)))
 
 
 class _SlangPyNativeWindowPresenter:
diff --git a/flashdreams/flashdreams/runtime_v2/selected_file.py b/flashdreams/flashdreams/runtime_v2/selected_file.py
index 5f162558c..c57a90659 100644
--- a/flashdreams/flashdreams/runtime_v2/selected_file.py
+++ b/flashdreams/flashdreams/runtime_v2/selected_file.py
@@ -15,6 +15,13 @@
 MAX_SELECTED_FILE_BATCH_BYTES = 8 * MAX_SELECTED_FILE_BYTES
 """Hard ceiling for the total bytes of one selected-files request."""
 
+FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS = 30.0
+"""Seconds to wait for a client window to show a picker before ``UNAVAILABLE``.
+
+The deadline starts when a request is handed to the window. Once the window
+reports the picker is shown, the user may take as long as they want.
+"""
+
 
 def clamp_selected_file_max_bytes(max_bytes: int | None) -> int:
     """Return a file-size budget that cannot exceed ``MAX_SELECTED_FILE_BYTES``.
@@ -97,7 +104,8 @@ class SelectedFilesStatus(Enum):
     """A chosen file did not match ``accept``. Checked before size."""
 
     UNAVAILABLE = "unavailable"
-    """The selector could not complete."""
+    """No pick was made: another picker was open, the client has no picker or
+    left, the picker was not shown in time, or a chosen file was unreadable."""
 
 
 def selected_file_policy_status(
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 0bf11bc33..6faa93d43 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -213,7 +213,6 @@ if (promptBackdrop !== null) {
 }
 
 let pendingFileRequest = null;
-let queuedFileSelectors = [];
 
 const hideFilePicker = () => {
   pendingFileRequest = null;
@@ -223,12 +222,6 @@ const hideFilePicker = () => {
     promptOnCancel = null;
     closePromptDialog();
   }
-  const next = queuedFileSelectors.shift();
-  if (next !== undefined) {
-    // The runtime may arm the next selector before this viewer's fetch
-    // callback runs; show it after the current dialog has fully settled.
-    window.queueMicrotask(() => openFileSelector(next));
-  }
 };
 
 const completeFileSelection = (requestId, status) => {
@@ -338,14 +331,10 @@ const openFileSelector = options => {
   }
   // ponytail: replies carry only the request id, so a prompt left open across a
   // session handoff can answer the next session's request for the same id.
-  // Upgrade path: echo the server's generation in replies and replace the old
-  // prompt when a newer generation arrives.
+  // Upgrade path: tag requests with a session id and echo it in replies.
   if (pendingFileRequest !== null) {
-    if (
-      pendingFileRequest.id !== requestId
-      && queuedFileSelectors.every(item => item.id !== requestId)
-    ) {
-      queuedFileSelectors.push(options);
+    if (pendingFileRequest.id !== requestId) {
+      completeFileSelection(requestId, "unavailable");
     }
     return;
   }
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 5f48e8b91..4948c065d 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -12,7 +12,7 @@
 import threading
 import time
 from collections import deque
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from dataclasses import dataclass
 from fractions import Fraction
 from importlib.resources import files
@@ -31,6 +31,7 @@
 from flashdreams.runtime_v2.cuda_utils import resolve_cuda_device
 from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BATCH_BYTES,
+    FileSelectionRequest,
     SelectedFile,
     SelectedFilesStatus,
     clamp_selected_file_max_bytes,
@@ -42,6 +43,7 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
+    FileSelectorOpenedUserInputEvent,
     FocusUserInputEvent,
     GamepadUserInputEvent,
     GameWheelUserInputEvent,
@@ -318,17 +320,6 @@ class _PendingFileSelection:
     multiple: bool
     """Whether this request may include more than one file."""
 
-    generation: int
-    """Gate generation that armed this request; a later generation drops it."""
-
-
-def _queued_file_selector_matches(
-    item: tuple[dict[str, Any], int], request_id: str, generation: int
-) -> bool:
-    """Return whether one queued selector payload is this request."""
-    payload, queued_generation = item
-    return payload.get("id") == request_id and queued_generation == generation
-
 
 class WebRTCServer:
     """Own the HTTP, signaling, input buffering, and media transport."""
@@ -361,12 +352,6 @@ def __init__(
         self._port = port
         self._startup_timeout_seconds = startup_timeout_seconds
         self._input_callback: Callable[[UserInputEvent], None] | None = None
-        self._file_selection_current_callback: Callable[[str, int], bool] | None = None
-        self._file_selection_may_show_callback: Callable[[str, int], bool] | None = None
-        self._file_selection_presented_callback: Callable[[str, int], None] | None = (
-            None
-        )
-        self._file_selection_invalidate_callback: Callable[[bool], None] | None = None
         self._started = threading.Event()
         self._startup_error: BaseException | None = None
         self._loop: asyncio.AbstractEventLoop | None = None
@@ -388,9 +373,7 @@ def __init__(
         self._client_connected = False
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._queued_file_selectors: list[tuple[dict[str, Any], int]] = []
         self._pending_file_requests: dict[str, _PendingFileSelection] = {}
-        self._file_selector_sent: set[tuple[str, int]] = set()
         self._file_selector_lock = threading.Lock()
         self._thread = threading.Thread(
             target=self._run_server,
@@ -482,190 +465,68 @@ def _send_cursor_options(self) -> None:
 
         self._sent_cursor_options = cursor_options
 
-    def request_selected_files(
-        self,
-        request_id: str,
-        initial_path: str | None = None,
-        *,
-        accept: Sequence[str] = (),
-        max_bytes: int | None = None,
-        multiple: bool = False,
-        generation: int,
-    ) -> None:
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the connected browser to open a file selector.
 
+        The browser cannot use a host path, so ``initial_path`` is ignored.
+        Without a connected viewer the request completes as ``UNAVAILABLE``.
+
         Args:
-            request_id: Stable selector-slot id from the UI control.
-            initial_path: Ignored; the browser picker cannot use a host path.
-            accept: Filename suffixes such as ``.png``. Empty allows any type.
-            max_bytes: Maximum file size in bytes, or ``None`` for the ceiling.
-            multiple: Whether the selector may return more than one file.
-            generation: Gate generation that admitted this request.
+            request: File selector to show.
         """
-        del initial_path
-        if not isinstance(request_id, str) or not request_id:
-            raise ValueError("request_id must be a non-empty string.")
-        suffixes = normalize_selected_file_accept(accept)
-        budget = clamp_selected_file_max_bytes(max_bytes)
-        payload: dict[str, Any] = {
-            "type": "file_selector",
-            "id": request_id,
-            "accept": list(suffixes),
-            "max_bytes": budget,
-            "multiple": multiple,
-        }
+        policy = _PendingFileSelection(
+            accept=normalize_selected_file_accept(request.accept),
+            max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
+            multiple=request.multiple,
+        )
         loop = self._loop
         if loop is None:
             raise RuntimeError("WebRTC server is not running.")
-        loop.call_soon_threadsafe(self._arm_file_selector, payload, generation)
-
-    def _arm_file_selector(self, payload: dict[str, Any], generation: int) -> None:
-        """Record pending policy and send or queue the selector request."""
-        request_id = payload["id"]
-        if not isinstance(request_id, str):
-            raise TypeError("file selector id must be a string.")
-        accept = payload["accept"]
-        max_bytes = payload["max_bytes"]
-        multiple = payload["multiple"]
-        if (
-            not isinstance(accept, list)
-            or not isinstance(max_bytes, int)
-            or not isinstance(multiple, bool)
-        ):
-            raise TypeError(
-                "file selector payload must include accept, max_bytes, and multiple."
+        loop.call_soon_threadsafe(self._arm_file_selector, request.request_id, policy)
+
+    def _arm_file_selector(
+        self, request_id: str, policy: _PendingFileSelection
+    ) -> None:
+        """Send the selector to the browser and remember its upload policy."""
+        channel = self._control_channel
+        if channel is None or channel.readyState != "open":
+            self._emit_selected_files(
+                self._timestamp_us() or np.uint64(0),
+                request_id,
+                status=SelectedFilesStatus.UNAVAILABLE,
             )
+            return
         with self._file_selector_lock:
-            if not self._file_selection_may_show(request_id, generation):
-                return
-            self._pending_file_requests[request_id] = _PendingFileSelection(
-                accept=tuple(accept),
-                max_bytes=max_bytes,
-                multiple=multiple,
-                generation=generation,
+            self._pending_file_requests[request_id] = policy
+        channel.send(
+            json.dumps(
+                {
+                    "type": "file_selector",
+                    "id": request_id,
+                    "accept": list(policy.accept),
+                    "max_bytes": policy.max_bytes,
+                    "multiple": policy.multiple,
+                }
             )
-            channel = self._control_channel
-            if channel is None or channel.readyState != "open":
-                self._queued_file_selectors.append((payload, generation))
-                return
-            self._file_selector_sent.add((request_id, generation))
-        channel.send(json.dumps(payload))
+        )
 
     def _take_pending_file_request(
         self, request_id: str
     ) -> _PendingFileSelection | None:
         """Return and consume the policy for ``request_id``, if it was pending."""
         with self._file_selector_lock:
-            policy = self._pending_file_requests.pop(request_id, None)
-            if policy is not None:
-                self._file_selector_sent.discard((request_id, policy.generation))
-            return policy
-
-    def _file_selection_is_current(self, request_id: str, generation: int) -> bool:
-        """Return whether the window gate still owns this in-flight request."""
-        if self._closed:
-            return False
-        callback = self._file_selection_current_callback
-        if callback is None:
-            return False
-        return callback(request_id, generation)
-
-    def _file_selection_may_show(self, request_id: str, generation: int) -> bool:
-        """Return whether this request should still be sent to the browser."""
-        if self._closed:
-            return False
-        callback = self._file_selection_may_show_callback
-        if callback is None:
-            return False
-        return callback(request_id, generation)
-
-    def _note_file_selector_presented(self, payload: dict[str, Any]) -> None:
-        """Forward a browser acknowledgement that the picker prompt is visible."""
-        request_id = payload.get("id")
-        if not isinstance(request_id, str) or not request_id:
-            raise ValueError("File selector acknowledgement requires a non-empty id.")
-        with self._file_selector_lock:
-            policy = self._pending_file_requests.get(request_id)
-        if policy is None or not self._file_selection_is_current(
-            request_id, policy.generation
-        ):
-            return
-        callback = self._file_selection_presented_callback
-        if callback is not None:
-            callback(request_id, policy.generation)
-
-    def _invalidate_file_selectors(self, *, deliver_unavailable: bool) -> None:
-        """Drop transport state and finish the window's current file generation."""
-        with self._file_selector_lock:
-            self._pending_file_requests.clear()
-            self._queued_file_selectors.clear()
-            self._file_selector_sent.clear()
-            callback = self._file_selection_invalidate_callback
-            if callback is not None:
-                callback(deliver_unavailable)
-
-    def drop_unsent_file_selector(self, request_id: str, generation: int) -> bool:
-        """Drop a selector that has not been sent to the browser.
-
-        Returns:
-            ``True`` when nothing was sent, so the window can release the
-            request. ``False`` when the browser may already be showing it.
-        """
-        with self._file_selector_lock:
-            if (request_id, generation) in self._file_selector_sent:
-                return False
-            self._queued_file_selectors = [
-                item
-                for item in self._queued_file_selectors
-                if not _queued_file_selector_matches(item, request_id, generation)
-            ]
-            pending = self._pending_file_requests.get(request_id)
-            if pending is not None and pending.generation == generation:
-                self._pending_file_requests.pop(request_id, None)
-            return True
+            return self._pending_file_requests.pop(request_id, None)
 
     def _complete_abandoned_file_selectors(self) -> None:
-        """Finish leftover picks because the interactive client is gone."""
-        self._invalidate_file_selectors(deliver_unavailable=True)
-
-    def _flush_queued_file_selectors(self) -> None:
-        """Send file-selector requests that arrived before the datachannel opened."""
+        """Answer every armed pick as ``UNAVAILABLE`` because the viewer left."""
         with self._file_selector_lock:
-            queued = self._queued_file_selectors
-            self._queued_file_selectors = []
-            ready: list[tuple[dict[str, Any], int]] = []
-            for payload, generation in queued:
-                request_id = payload["id"]
-                if isinstance(request_id, str) and self._file_selection_may_show(
-                    request_id, generation
-                ):
-                    ready.append((payload, generation))
-                elif isinstance(request_id, str):
-                    pending = self._pending_file_requests.get(request_id)
-                    if pending is not None and pending.generation == generation:
-                        self._pending_file_requests.pop(request_id, None)
-        for payload, generation in ready:
-            channel = self._control_channel
-            request_id = payload["id"]
-            if (
-                channel is None
-                or channel.readyState != "open"
-                or not isinstance(request_id, str)
-            ):
-                with self._file_selector_lock:
-                    if isinstance(request_id, str) and self._file_selection_may_show(
-                        request_id, generation
-                    ):
-                        self._queued_file_selectors.append((payload, generation))
-                continue
-            with self._file_selector_lock:
-                if not self._file_selection_may_show(request_id, generation):
-                    pending = self._pending_file_requests.get(request_id)
-                    if pending is not None and pending.generation == generation:
-                        self._pending_file_requests.pop(request_id, None)
-                    continue
-                self._file_selector_sent.add((request_id, generation))
-            channel.send(json.dumps(payload))
+            abandoned = tuple(self._pending_file_requests)
+            self._pending_file_requests.clear()
+        timestamp_us = self._timestamp_us() or np.uint64(0)
+        for request_id in abandoned:
+            self._emit_selected_files(
+                timestamp_us, request_id, status=SelectedFilesStatus.UNAVAILABLE
+            )
 
     def event_timestamp_us(self) -> np.uint64:
         """Return the current timestamp relative to this server's first session.
@@ -729,7 +590,8 @@ def open(self, session_desc: SessionDesc) -> None:
             # Keep timestamps comparable across sessions so events buffered
             # during a handoff retain their real order.
             self._event_origin_ns = time.monotonic_ns()
-        self._invalidate_file_selectors(deliver_unavailable=False)
+        with self._file_selector_lock:
+            self._pending_file_requests.clear()
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the dimensions used to present subsequent UI frames.
@@ -786,77 +648,6 @@ def register_input_callback(
             raise RuntimeError("An input callback is already registered.")
         self._input_callback = callback
 
-    def register_file_selection_current_callback(
-        self, callback: Callable[[str, int], bool]
-    ) -> None:
-        """Register the gate check for in-flight file-selector work.
-
-        Args:
-            callback: ``True`` when ``request_id`` is still current for
-                ``generation``.
-
-        Raises:
-            RuntimeError: A callback has already been registered.
-        """
-        if self._file_selection_current_callback is not None:
-            raise RuntimeError(
-                "A file-selection current callback is already registered."
-            )
-        self._file_selection_current_callback = callback
-
-    def register_file_selection_may_show_callback(
-        self, callback: Callable[[str, int], bool]
-    ) -> None:
-        """Register the check for whether a selector should still be sent.
-
-        Args:
-            callback: ``True`` when ``request_id`` is current and the app is
-                still waiting for the browser to show it.
-
-        Raises:
-            RuntimeError: A callback has already been registered.
-        """
-        if self._file_selection_may_show_callback is not None:
-            raise RuntimeError(
-                "A file-selection may-show callback is already registered."
-            )
-        self._file_selection_may_show_callback = callback
-
-    def register_file_selection_presented_callback(
-        self, callback: Callable[[str, int], None]
-    ) -> None:
-        """Register the function called when the browser shows a picker prompt.
-
-        Args:
-            callback: Receives the request id and gate generation.
-
-        Raises:
-            RuntimeError: A callback has already been registered.
-        """
-        if self._file_selection_presented_callback is not None:
-            raise RuntimeError(
-                "A file-selection presented callback is already registered."
-            )
-        self._file_selection_presented_callback = callback
-
-    def register_file_selection_invalidate_callback(
-        self, callback: Callable[[bool], None]
-    ) -> None:
-        """Register the function that finishes a file-selection generation.
-
-        Args:
-            callback: Called with ``True`` to emit ``unavailable`` for leftovers
-                and ``False`` to drop them without delivering.
-
-        Raises:
-            RuntimeError: A callback has already been registered.
-        """
-        if self._file_selection_invalidate_callback is not None:
-            raise RuntimeError(
-                "A file-selection invalidate callback is already registered."
-            )
-        self._file_selection_invalidate_callback = callback
-
     def write(self, result: StepResult) -> None:
         """Materialize and admit one generated result to the sender mailbox.
 
@@ -1091,16 +882,8 @@ def emit(
             files: tuple[SelectedFile, ...] = (),
         ) -> None:
             nonlocal emitted
-            if not self._file_selection_is_current(request_id, policy.generation):
-                raise web.HTTPConflict(
-                    reason="No pending file selection for this request_id."
-                )
             self._emit_selected_files(
-                timestamp_us,
-                request_id,
-                status=status,
-                files=files,
-                generation=policy.generation,
+                timestamp_us, request_id, status=status, files=files
             )
             emitted = True
 
@@ -1180,10 +963,7 @@ def emit(
             raise
         finally:
             if not emitted:
-                try:
-                    emit(SelectedFilesStatus.UNAVAILABLE)
-                except web.HTTPConflict:
-                    pass
+                emit(SelectedFilesStatus.UNAVAILABLE)
 
     async def _offer(self, request: web.Request) -> web.Response:
         """Negotiate one browser peer connection."""
@@ -1238,14 +1018,12 @@ def on_datachannel(channel: Any) -> None:
                     def on_open() -> None:
                         if self._peer_connection is peer_connection:
                             self._send_cursor_options()
-                            self._flush_queued_file_selectors()
 
                     if (
                         self._peer_connection is peer_connection
                         and channel.readyState == "open"
                     ):
                         self._send_cursor_options()
-                        self._flush_queued_file_selectors()
 
                 @channel.on("message")
                 def on_message(message: Any) -> None:
@@ -1328,7 +1106,6 @@ async def on_connectionstatechange() -> None:
             self._sent_cursor_options = None
             if control_channel is not None and control_channel.readyState == "open":
                 self._send_cursor_options()
-                self._flush_queued_file_selectors()
             query_string = request.rel_url.raw_query_string
             if query_string:
                 timestamp_us = self._timestamp_us()
@@ -1507,8 +1284,17 @@ def _buffer_browser_message(
         elif event_type == "close":
             event = CloseUserInputEvent(timestamp=timestamp_us)
         elif event_type == "file_selector_ack":
-            self._note_file_selector_presented(payload)
-            return
+            request_id = payload.get("id")
+            if not isinstance(request_id, str) or not request_id:
+                raise ValueError(
+                    "File selector acknowledgement requires a non-empty id."
+                )
+            with self._file_selector_lock:
+                if request_id not in self._pending_file_requests:
+                    return
+            event = FileSelectorOpenedUserInputEvent(
+                timestamp=timestamp_us, request_id=request_id
+            )
         elif event_type == "file_selector_result":
             request_id = payload.get("id")
             if not isinstance(request_id, str) or not request_id:
@@ -1522,17 +1308,9 @@ def _buffer_browser_message(
                     "File selector result must not set status ok; send files "
                     "with POST /api/files."
                 )
-            policy = self._take_pending_file_request(request_id)
-            if policy is None:
+            if self._take_pending_file_request(request_id) is None:
                 return
-            if not self._file_selection_is_current(request_id, policy.generation):
-                return
-            self._emit_selected_files(
-                timestamp_us,
-                request_id,
-                status=status,
-                generation=policy.generation,
-            )
+            self._emit_selected_files(timestamp_us, request_id, status=status)
             return
         else:
             raise ValueError("Unsupported browser event type.")
@@ -1552,7 +1330,6 @@ def _emit_selected_files(
         *,
         status: SelectedFilesStatus,
         files: tuple[SelectedFile, ...] = (),
-        generation: int,
     ) -> None:
         """Append one selected-files event."""
         self._append_event(
@@ -1561,7 +1338,6 @@ def _emit_selected_files(
                 request_id=request_id,
                 status=status,
                 files=files,
-                _generation=generation,
             )
         )
 
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 8cd2bc871..192dbbe49 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -11,6 +11,8 @@
 from dataclasses import dataclass
 from pathlib import Path
 
+from numpy import uint64
+
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.loop import (
     IModelLoop,
@@ -23,8 +25,17 @@
 from flashdreams.runtime_v2.coordination import StepAgreement
 from flashdreams.runtime_v2.event_buffer import EventBuffer
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
+from flashdreams.runtime_v2.selected_file import (
+    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
+    FileSelectionRequest,
+    SelectedFilesStatus,
+)
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
+from flashdreams.runtime_v2.user_input_event import (
+    FileSelectorOpenedUserInputEvent,
+    SelectedFilesUserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 _LOGGER = logging.getLogger(__name__)
@@ -47,6 +58,88 @@ class _ChunkTraceLog:
     previous_propagate: bool
 
 
+class _FileSelections:
+    """Allow one client file picker at a time for a session, on the UI thread.
+
+    A request made while another picker is active completes as
+    ``UNAVAILABLE``. The active request has a deadline until its window reports
+    the picker opened; after that the user may take as long as they want.
+    Results for any other id are dropped, so each request gets one result.
+    """
+
+    # ponytail: a picker that opens after its deadline, or one left open across a
+    # session replacement, can sit beside the next one. Upgrade path: have
+    # windows report when a dialog closes and wait for that before the next.
+
+    def __init__(
+        self,
+        window: IClientWindow,
+        *,
+        timeout_seconds: float = FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self._window = window
+        self._timeout_seconds = timeout_seconds
+        self._clock = clock
+        self._active: FileSelectionRequest | None = None
+        self._deadline: float | None = None
+
+    def request(self, request: FileSelectionRequest) -> list[UserInputEvent]:
+        """Start ``request`` and return any result known right away."""
+        active = self._active
+        if active is not None:
+            if active.request_id == request.request_id:
+                return []
+            return [self._unavailable(request)]
+        self._active = request
+        self._deadline = self._clock() + self._timeout_seconds
+        try:
+            result = self._window.request_selected_files(request)
+        except Exception:
+            _LOGGER.exception("File selector %r failed to start.", request.request_id)
+            result = self._unavailable(request)
+        if result is None:
+            return []
+        self._active = None
+        return [result]
+
+    def filter(self, events: list[UserInputEvent]) -> list[UserInputEvent]:
+        """Apply window file events and the deadline; return events for the loops."""
+        kept: list[UserInputEvent] = []
+        for event in events:
+            active = self._active
+            if isinstance(event, FileSelectorOpenedUserInputEvent):
+                if active is not None and active.request_id == event.request_id:
+                    self._deadline = None
+            elif isinstance(event, SelectedFilesUserInputEvent):
+                if active is not None and active.request_id == event.request_id:
+                    kept.append(event)
+                    self._active = None
+            else:
+                kept.append(event)
+        if (
+            self._active is not None
+            and self._deadline is not None
+            and self._clock() >= self._deadline
+        ):
+            _LOGGER.warning(
+                "File selector %r was not shown within %g seconds.",
+                self._active.request_id,
+                self._timeout_seconds,
+            )
+            kept.append(self._unavailable(self._active))
+            self._active = None
+        return kept
+
+    @staticmethod
+    def _unavailable(request: FileSelectionRequest) -> SelectedFilesUserInputEvent:
+        return SelectedFilesUserInputEvent(
+            timestamp=uint64(0),
+            request_id=request.request_id,
+            status=SelectedFilesStatus.UNAVAILABLE,
+        )
+
+
 def _log_secondary_failure(message: str, error: BaseException) -> None:
     """Log a cleanup failure that cannot replace an earlier exception."""
     _LOGGER.error(message, exc_info=error)
@@ -115,6 +208,7 @@ def run_session(
     agreement: StepAgreement | None = None
 
     event_buffer = EventBuffer()
+    file_selections = None if window is None else _FileSelections(window)
     model_thread_handle: threading.Thread | None = None
     ui_loop: IUILoop[object] | None = None
     model_loop: IModelLoop[object] | None = None
@@ -157,14 +251,15 @@ def expire_if_due() -> bool:
             return False
 
         def collect_input() -> None:
-            if window is None:
+            if window is None or file_selections is None:
                 return
-            event_buffer.append(window.get_user_input_events())
+            events = window.get_user_input_events().get_events()
+            event_buffer.append(UserInputEvents(file_selections.filter(events)))
 
         def run_ui_once(*, step_requested: bool = True) -> None:
             """Process UI lifecycle control and run a requested UI step."""
             nonlocal next_session_desc
-            if ui_loop is None or window is None:
+            if ui_loop is None or window is None or file_selections is None:
                 return
             events, generation = event_buffer.read(_UI_READER_ID)
             result: list[StepResult] | None = None
@@ -177,7 +272,7 @@ def run_ui_once(*, step_requested: bool = True) -> None:
 
                 request = ui_loop.flush_ui_loop_requests()
                 if request is not None:
-                    immediate = _apply_window_requests(window, request)
+                    immediate = _apply_window_requests(window, request, file_selections)
                     if immediate:
                         event_buffer.append(UserInputEvents(immediate))
                     if request.new_session is not None:
@@ -410,7 +505,9 @@ def should_end_ui() -> bool:
 
 
 def _apply_window_requests(
-    window: IClientWindow, request: UILoopRequests
+    window: IClientWindow,
+    request: UILoopRequests,
+    file_selections: _FileSelections,
 ) -> list[UserInputEvent]:
     """Apply UI window settings in request order; return immediate file results."""
     if request.hide_cursor is not None:
@@ -419,8 +516,11 @@ def _apply_window_requests(
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
-    results = (window.request_selected_files(item) for item in request.file_selections)
-    return [result for result in results if result is not None]
+    return [
+        result
+        for item in request.file_selections
+        for result in file_selections.request(item)
+    ]
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 089e72608..653be1734 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -253,9 +253,6 @@ def get_type_name(cls) -> str:
     files: tuple[SelectedFile, ...] = ()
     """Chosen files. Empty unless ``status`` is ``OK``."""
 
-    _generation: int = 0
-    """Window generation that admitted this request. Applications ignore it."""
-
     def __post_init__(self) -> None:
         """Reject an ``ok`` event without files, or files on a failed pick."""
         has_files = bool(self.files)
@@ -267,6 +264,23 @@ def __post_init__(self) -> None:
             raise ValueError("failed selected-files events must not include files.")
 
 
+@dataclass(frozen=True, slots=True, eq=False)
+class FileSelectorOpenedUserInputEvent(UserInputEvent):
+    """A client window showed the picker for one file-selector request.
+
+    The runtime consumes it to stop that request's presentation deadline.
+    Applications never receive it.
+    """
+
+    @classmethod
+    def get_type_name(cls) -> str:
+        """Return the event type name."""
+        return "file_selector_opened"
+
+    request_id: str
+    """``request_id`` of the request whose picker is now shown."""
+
+
 @dataclass(frozen=True, slots=True, eq=False)
 class UnknownUserInputEvent(UserInputEvent):
     """User input event for an unknown input modality."""
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 412d01ec0..380829fb7 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -10,23 +10,11 @@
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
-from flashdreams.runtime_v2.file_selection_gate import (
-    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
-    FileSelectionGate,
-    FileSelectionPresentationTimer,
-    QueuedFileSelection,
-)
-from flashdreams.runtime_v2.selected_file import (
-    FileSelectionRequest,
-    SelectedFilesStatus,
-)
+from flashdreams.runtime_v2.selected_file import FileSelectionRequest
 from flashdreams.runtime_v2.serving.webrtc_server import WebRTCServer
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import (
-    SelectedFilesUserInputEvent,
-    UserInputEvent,
-)
+from flashdreams.runtime_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
@@ -45,8 +33,7 @@ class WebRTCClientWindow(IClientWindow):
 
     Disconnecting releases only that browser's peer connection. The server and
     current session stay available for a refreshed or replacement client until
-    the application is explicitly stopped. Leftover and in-flight file picks
-    complete as unavailable; a replacement viewer does not inherit them.
+    the application is explicitly stopped.
     """
 
     def __init__(
@@ -55,9 +42,6 @@ def __init__(
         host: str = "127.0.0.1",
         port: int = 0,
         startup_timeout_seconds: float = 10.0,
-        presentation_timeout_seconds: float = (
-            FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
-        ),
     ) -> None:
         """Create the WebRTC backend.
 
@@ -68,24 +52,11 @@ def __init__(
             host: Interface on which the HTTP server listens.
             port: Listening port. Zero asks the operating system to choose one.
             startup_timeout_seconds: Maximum time to wait for server startup.
-            presentation_timeout_seconds: How long to wait for the browser to
-                show the picker prompt. After that acknowledgement, the user
-                may take as long as they want.
-
-        Raises:
-            ValueError: The presentation deadline is not positive.
         """
         self._input_events: deque[UserInputEvent] = deque()
         self._hide_cursor = False
         self._lock_cursor_to_window = False
-        self._file_gate = FileSelectionGate()
-        self._presentation = FileSelectionPresentationTimer(
-            self._file_gate,
-            timeout_seconds=presentation_timeout_seconds,
-            on_expired=self._on_file_selection_unpresented,
-        )
         self._input_lock = threading.Lock()
-        self._session_file_generation = 0
         # Offset from the server's stable clock to the current session's clock.
         self._session_event_offset_us = uint64(0)
         self.server = WebRTCServer(
@@ -97,29 +68,10 @@ def __init__(
         def handle_input(event: UserInputEvent) -> None:
             """Buffer one backend event for the ``InputSource`` protocol."""
             # TODO: do we really need to buffer all events? Some mouse moves may be superseded by later ones.
-            nxt = None
             with self._input_lock:
-                if isinstance(event, SelectedFilesUserInputEvent):
-                    self._presentation.finished(event.request_id, event._generation)
-                    claimed, nxt = self._file_gate.complete(
-                        event.request_id, event._generation
-                    )
-                    if claimed:
-                        self._input_events.append(event)
-                else:
-                    self._input_events.append(event)
-            if nxt is not None:
-                self._start_file_selection(nxt)
+                self._input_events.append(event)
 
         self.server.register_input_callback(handle_input)
-        self.server.register_file_selection_current_callback(self._file_gate.is_current)
-        self.server.register_file_selection_may_show_callback(self._file_gate.may_show)
-        self.server.register_file_selection_presented_callback(
-            self._presentation.presented
-        )
-        self.server.register_file_selection_invalidate_callback(
-            self._invalidate_file_selections
-        )
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the browser window."""
@@ -151,88 +103,7 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def request_selected_files(self, request: FileSelectionRequest) -> None:
         """Ask the connected browser to open a file selector."""
-        admission = self._file_gate.submit(QueuedFileSelection.from_request(request))
-        if admission.unavailable:
-            self._append_unavailable(
-                request.request_id, generation=self._file_gate.generation
-            )
-            return
-        if admission.started is not None:
-            self._start_file_selection(admission.started)
-
-    def _on_file_selection_unpresented(
-        self, expired: tuple[QueuedFileSelection, ...]
-    ) -> None:
-        """Answer requests whose browser prompt was not shown in time.
-
-        A prompt that was never sent does not need to keep the picker slot.
-        A prompt that was sent might still appear, so that slot stays occupied
-        until the browser finishes and the late result is discarded.
-        """
-        if not expired:
-            return
-        for item in expired:
-            self._append_unavailable(item.request_id, generation=item.generation)
-        active = expired[0]
-        if not self.server.drop_unsent_file_selector(
-            active.request_id, active.generation
-        ):
-            return
-        self._presentation.finished(active.request_id, active.generation)
-        _delivered, nxt = self._file_gate.complete(active.request_id, active.generation)
-        if nxt is not None:
-            self._start_file_selection(nxt)
-
-    def _append_unavailable(self, request_id: str, *, generation: int) -> None:
-        """Queue one unavailable file-selector result unless its session ended.
-
-        ``open`` drains the gate, then records the new session's first
-        generation and clears the queue under the same lock. A viewer
-        disconnect also drains the gate but keeps the session, so its results
-        are still delivered.
-        """
-        timestamp = self.server.event_timestamp_us()
-        with self._input_lock:
-            if generation < self._session_file_generation:
-                return
-            self._input_events.append(
-                SelectedFilesUserInputEvent(
-                    timestamp=timestamp,
-                    request_id=request_id,
-                    status=SelectedFilesStatus.UNAVAILABLE,
-                    _generation=generation,
-                )
-            )
-
-    def _invalidate_file_selections(self, deliver_unavailable: bool) -> None:
-        """Finish this client generation; optionally report leftovers as unavailable."""
-        self._presentation.cancel()
-        leftover = self._file_gate.drain()
-        if not deliver_unavailable or not leftover:
-            return
-        timestamp = self.server.event_timestamp_us()
-        with self._input_lock:
-            for item in leftover:
-                self._input_events.append(
-                    SelectedFilesUserInputEvent(
-                        timestamp=timestamp,
-                        request_id=item.request_id,
-                        status=SelectedFilesStatus.UNAVAILABLE,
-                        _generation=item.generation,
-                    )
-                )
-
-    def _start_file_selection(self, pending: QueuedFileSelection) -> None:
-        """Arm the WebRTC server for one file-selector request."""
-        self._presentation.arm(pending)
-        self.server.request_selected_files(
-            pending.request_id,
-            initial_path=pending.initial_path,
-            accept=pending.accept,
-            max_bytes=pending.max_bytes,
-            multiple=pending.multiple,
-            generation=pending.generation,
-        )
+        self.server.request_selected_files(request)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Implement ``OutputSink.open`` by configuring WebRTC output.
@@ -244,7 +115,6 @@ def open(self, session_desc: SessionDesc) -> None:
         session_event_offset_us = self.server.event_timestamp_us()
         with self._input_lock:
             self._input_events.clear()
-            self._session_file_generation = self._file_gate.generation
             self._session_event_offset_us = session_event_offset_us
 
     def get_user_input_events(self) -> UserInputEvents:
@@ -286,5 +156,4 @@ def metrics_snapshot(self) -> dict[str, float | int]:
 
     def close(self) -> None:
         """Implement ``OutputSink.close`` by releasing WebRTC resources."""
-        self._invalidate_file_selections(False)
         self.server.close()
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index ea75d1c7d..c34729212 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -29,6 +29,7 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
+    FileSelectorOpenedUserInputEvent,
     GamepadUserInputEvent,
     KeyboardInputState,
     KeyboardUserInputEvent,
@@ -61,42 +62,6 @@ def _file_request(
     )
 
 
-class _ChooserProcess:
-    """Desktop chooser stand-in that has already exited."""
-
-    def __init__(self, *, returncode: int, stdout: str = "", stderr: str = "") -> None:
-        self.returncode = returncode
-        self._stdout = stdout
-        self._stderr = stderr
-
-    def poll(self) -> int:
-        """Return the exit status. The process is already finished."""
-        return self.returncode
-
-    def communicate(self, timeout: float | None = None) -> tuple[str, str]:
-        """Return the captured chooser output."""
-        del timeout
-        return self._stdout, self._stderr
-
-
-class _RunningChooser:
-    """Chooser process that stays alive until ``communicate``."""
-
-    def __init__(self, *, stdout: str) -> None:
-        self.returncode: int | None = None
-        self._stdout = stdout
-
-    def poll(self) -> None:
-        """Report that the chooser is still running."""
-        return None
-
-    def communicate(self, timeout: float | None = None) -> tuple[str, str]:
-        """Finish the chooser and return its output."""
-        del timeout
-        self.returncode = 0
-        return self._stdout, ""
-
-
 def _wait_for_input_events(window: NativeWindowClientWindow) -> list[object]:
     for _ in range(100):
         events = window.get_user_input_events().get_events()
@@ -769,245 +734,6 @@ def fail_picker(
     assert event.files == ()
 
 
-def test_native_window_serves_one_file_selection_at_a_time(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    first_entered = threading.Event()
-    first_released = threading.Event()
-    calls: list[tuple[str, ...]] = []
-
-    def picker(
-        *,
-        initial_dir: str,
-        accept: tuple[str, ...] = (),
-        multiple: bool = False,
-        on_presented: object = None,
-    ) -> tuple[str, ...]:
-        del initial_dir, multiple, on_presented
-        calls.append(accept)
-        if len(calls) == 1:
-            first_entered.set()
-            assert first_released.wait(timeout=2.0)
-        return ()
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-    )
-    window.open(_session_desc())
-    window.request_selected_files(
-        _file_request("open-1", str(tmp_path), accept=(".bin",))
-    )
-    assert first_entered.wait(timeout=2.0)
-    window.request_selected_files(
-        _file_request("open-2", str(tmp_path), accept=(".raw",))
-    )
-    assert calls == [(".bin",)]
-    first_released.set()
-    events = []
-    for _ in range(200):
-        events.extend(window.get_user_input_events().get_events())
-        if len(events) >= 2:
-            break
-        time.sleep(0.01)
-    window.close()
-
-    picks = [
-        event for event in events if isinstance(event, SelectedFilesUserInputEvent)
-    ]
-    assert [event.request_id for event in picks] == ["open-1", "open-2"]
-    assert all(event.status is SelectedFilesStatus.CANCELLED for event in picks)
-    assert calls == [(".bin",), (".raw",)]
-
-
-def test_native_window_ignores_duplicate_in_flight_file_selection_id(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    released = threading.Event()
-    entered = threading.Event()
-    calls: list[int] = []
-
-    def picker(
-        *,
-        initial_dir: str,
-        accept: tuple[str, ...] = (),
-        multiple: bool = False,
-        on_presented: object = None,
-    ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple, on_presented
-        calls.append(1)
-        entered.set()
-        if len(calls) == 1:
-            assert released.wait(timeout=2.0)
-        return ()
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-    )
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    assert entered.wait(timeout=2.0)
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    time.sleep(0.05)
-    assert calls == [1]
-    released.set()
-    events = _wait_for_input_events(window)
-    window.close()
-
-    assert len(events) == 1
-    event = events[0]
-    assert isinstance(event, SelectedFilesUserInputEvent)
-    assert event.request_id == "open-1"
-    assert event.status is SelectedFilesStatus.CANCELLED
-
-
-def test_native_window_close_completes_leftover_file_selections(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    entered = threading.Event()
-    released = threading.Event()
-    late = tmp_path / "late.bin"
-    late.write_bytes(b"late")
-
-    def picker(
-        *,
-        initial_dir: str,
-        accept: tuple[str, ...] = (),
-        multiple: bool = False,
-        on_presented: object = None,
-    ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple, on_presented
-        entered.set()
-        assert released.wait(timeout=2.0)
-        return (str(late),)
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-    )
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    window.request_selected_files(_file_request("open-2", str(tmp_path)))
-    assert entered.wait(timeout=2.0)
-    presenter.pending_events.put(("close", None))
-    events = window.get_user_input_events().get_events()
-    released.set()
-    time.sleep(0.05)
-    extra = window.get_user_input_events().get_events()
-    window.close()
-
-    assert extra == []
-    picks = [
-        event for event in events[:-1] if isinstance(event, SelectedFilesUserInputEvent)
-    ]
-    assert [event.request_id for event in picks] == ["open-1", "open-2"]
-    assert all(
-        event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
-        for event in picks
-    )
-    assert isinstance(events[-1], CloseUserInputEvent)
-
-
-def test_native_window_replacement_open_drops_leftover_file_selections(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    entered = threading.Event()
-    released = threading.Event()
-    calls: list[int] = []
-
-    def picker(
-        *,
-        initial_dir: str,
-        accept: tuple[str, ...] = (),
-        multiple: bool = False,
-        on_presented: object = None,
-    ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple, on_presented
-        calls.append(1)
-        entered.set()
-        assert released.wait(timeout=2.0)
-        return (str(tmp_path / "late.bin"),)
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-    )
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    window.request_selected_files(_file_request("open-2", str(tmp_path)))
-    assert entered.wait(timeout=2.0)
-    window.open(_session_desc())
-    events = window.get_user_input_events().get_events()
-    released.set()
-    time.sleep(0.05)
-    extra = window.get_user_input_events().get_events()
-    window.close()
-
-    assert events == []
-    assert extra == []
-    assert calls == [1]
-
-
-def test_native_window_stale_picker_does_not_complete_reused_request_id(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    first_entered = threading.Event()
-    first_released = threading.Event()
-    second_entered = threading.Event()
-    second_released = threading.Event()
-    zombie = tmp_path / "zombie.bin"
-    zombie.write_bytes(b"old")
-    calls: list[int] = []
-
-    def picker(
-        *,
-        initial_dir: str,
-        accept: tuple[str, ...] = (),
-        multiple: bool = False,
-        on_presented: object = None,
-    ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple, on_presented
-        calls.append(1)
-        if len(calls) == 1:
-            first_entered.set()
-            assert first_released.wait(timeout=2.0)
-            return (str(zombie),)
-        second_entered.set()
-        assert second_released.wait(timeout=2.0)
-        return ()
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-    )
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    assert first_entered.wait(timeout=2.0)
-    window.close()
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    assert second_entered.wait(timeout=2.0)
-    first_released.set()
-    time.sleep(0.05)
-    assert window.get_user_input_events().get_events() == []
-    second_released.set()
-    events = _wait_for_input_events(window)
-    window.close()
-
-    assert len(events) == 1
-    event = events[0]
-    assert isinstance(event, SelectedFilesUserInputEvent)
-    assert event.request_id == "open-1"
-    assert event.status is SelectedFilesStatus.CANCELLED
-    assert event.files == ()
-
-
 def test_selected_files_from_paths_skips_unreadable_and_oversize(
     tmp_path: Path,
 ) -> None:
@@ -1041,247 +767,9 @@ def test_selected_files_from_paths_skips_unreadable_and_oversize(
     assert status is SelectedFilesStatus.DISALLOWED_TYPE
 
 
-def test_ask_open_filename_linux_uses_zenity(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-    calls: list[list[str]] = []
-
-    def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
-        del kwargs
-        calls.append(argv)
-        return _ChooserProcess(returncode=0, stdout="/tmp/seed.png\n")
-
-    monkeypatch.setattr(native_window_module.subprocess, "Popen", fake_popen)
-    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == (
-        "/tmp/seed.png",
-    )
-    assert calls[0][0] == "/usr/bin/zenity"
-    assert "--file-selection" in calls[0]
-    assert any(arg.startswith("--filename=/tmp/") for arg in calls[0])
-    assert not any(arg.startswith("--file-filter=") for arg in calls[0])
-    assert native_window_module._ask_open_filename_linux(
-        initial_dir="/tmp",
-        accept=(".png", ".jpg"),
-    ) == ("/tmp/seed.png",)
-    assert "--file-filter=Accepted | *.png *.jpg" in calls[1]
-
-
-def test_ask_open_filename_linux_keeps_trailing_spaces_in_a_filename(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-    monkeypatch.setattr(
-        native_window_module.subprocess,
-        "Popen",
-        lambda argv, **kwargs: _ChooserProcess(
-            returncode=0, stdout="/tmp/report.bin \n"
-        ),
-    )
-    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == (
-        "/tmp/report.bin ",
-    )
-
-
-def test_ask_open_filename_linux_cancel_is_empty(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-    monkeypatch.setattr(
-        native_window_module.subprocess,
-        "Popen",
-        lambda argv, **kwargs: _ChooserProcess(returncode=1, stdout=""),
-    )
-    assert native_window_module._ask_open_filename_linux(initial_dir="/tmp") == ()
-
-
-def test_ask_open_filename_linux_error_raises(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-    monkeypatch.setattr(
-        native_window_module.subprocess,
-        "Popen",
-        lambda argv, **kwargs: _ChooserProcess(
-            returncode=5, stdout="", stderr="no display"
-        ),
-    )
-    with pytest.raises(RuntimeError, match="exit 5"):
-        native_window_module._ask_open_filename_linux(initial_dir="/tmp")
-
-
-def test_ask_open_filename_linux_multiple_uses_slash_separator(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-    calls: list[list[str]] = []
-
-    def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
-        del kwargs
-        calls.append(argv)
-        return _ChooserProcess(returncode=0, stdout="/tmp/foo\nbar.bin//tmp/baz.bin\n")
-
-    monkeypatch.setattr(native_window_module.subprocess, "Popen", fake_popen)
-    assert native_window_module._ask_open_filename_linux(
-        initial_dir="/tmp", multiple=True
-    ) == ("/tmp/foo\nbar.bin", "/tmp/baz.bin")
-    assert "--multiple" in calls[0]
-    assert "--separator=/" in calls[0]
-
-
-def test_ask_open_filename_linux_falls_back_to_kdialog(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/kdialog" if name == "kdialog" else None,
-    )
-    calls: list[list[str]] = []
-
-    def fake_popen(argv: list[str], **kwargs: object) -> _ChooserProcess:
-        del kwargs
-        calls.append(argv)
-        return _ChooserProcess(returncode=0, stdout="'/tmp/a.bin' '/tmp/b.bin'\n")
-
-    monkeypatch.setattr(native_window_module.subprocess, "Popen", fake_popen)
-    assert native_window_module._ask_open_filename_linux(
-        initial_dir="/tmp", multiple=True
-    ) == ("/tmp/a.bin", "/tmp/b.bin")
-    assert calls[0][0] == "/usr/bin/kdialog"
-    assert "--getopenfilename" in calls[0]
-    assert "--multiple" in calls[0]
-
-
-def test_ask_open_filename_linux_running_chooser_is_presented(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        native_window_module.shutil,
-        "which",
-        lambda name: "/usr/bin/zenity" if name == "zenity" else None,
-    )
-    presented: list[bool] = []
-    monkeypatch.setattr(
-        native_window_module.subprocess,
-        "Popen",
-        lambda argv, **kwargs: _RunningChooser(stdout="/tmp/seed.png\n"),
-    )
-    assert native_window_module._ask_open_filename_linux(
-        initial_dir="/tmp",
-        on_presented=lambda: presented.append(True),
-    ) == ("/tmp/seed.png",)
-    assert presented == [True]
-
-
-def test_native_window_unpresented_picker_does_not_keep_a_late_result(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    entered = threading.Event()
-    released = threading.Event()
-    chosen = tmp_path / "late.bin"
-    chosen.write_bytes(b"late")
-    calls: list[int] = []
-
-    def picker(
-        *,
-        initial_dir: str,
-        accept: tuple[str, ...] = (),
-        multiple: bool = False,
-        on_presented: object = None,
-    ) -> tuple[str, ...]:
-        del initial_dir, accept, multiple, on_presented
-        calls.append(1)
-        if len(calls) == 1:
-            entered.set()
-            assert released.wait(timeout=2.0)
-            return (str(chosen),)
-        return ()
-
-    monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-        presentation_timeout_seconds=0.05,
-    )
-    window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    assert entered.wait(timeout=2.0)
-    expired = _wait_for_input_events(window)
-    window.request_selected_files(_file_request("open-2", str(tmp_path)))
-    refused = _wait_for_input_events(window)
-    released.set()
-    time.sleep(0.05)
-    late = window.get_user_input_events().get_events()
-    window.request_selected_files(_file_request("open-3", str(tmp_path)))
-    resumed = _wait_for_input_events(window)
-    window.close()
-
-    assert len(expired) == 1
-    assert isinstance(expired[0], SelectedFilesUserInputEvent)
-    assert expired[0].request_id == "open-1"
-    assert expired[0].status is SelectedFilesStatus.UNAVAILABLE
-    assert len(refused) == 1
-    assert isinstance(refused[0], SelectedFilesUserInputEvent)
-    assert refused[0].request_id == "open-2"
-    assert refused[0].status is SelectedFilesStatus.UNAVAILABLE
-    assert late == []
-    assert len(resumed) == 1
-    assert isinstance(resumed[0], SelectedFilesUserInputEvent)
-    assert resumed[0].request_id == "open-3"
-    assert resumed[0].status is SelectedFilesStatus.CANCELLED
-
-
-def test_native_window_drops_a_result_from_a_retired_session() -> None:
-    presenter = _Presenter()
-    window = NativeWindowClientWindow(presenter_factory=_presenter_factory(presenter))
-    window.open(_session_desc())
-    retired = window._file_gate.generation
-    window.open(_session_desc())
-    window._enqueue_selected_files(
-        "open-1", generation=retired, status=SelectedFilesStatus.UNAVAILABLE
-    )
-    window._enqueue_selected_files(
-        "open-2",
-        generation=window._file_gate.generation,
-        status=SelectedFilesStatus.UNAVAILABLE,
-    )
-    events = window.get_user_input_events().get_events()
-    window.close()
-
-    assert [
-        event.request_id
-        for event in events
-        if isinstance(event, SelectedFilesUserInputEvent)
-    ] == ["open-2"]
-
-
-def test_native_window_presented_picker_waits_past_the_deadline(
+def test_native_window_reports_opened_before_the_result(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    entered = threading.Event()
-    released = threading.Event()
-
     def picker(
         *,
         initial_dir: str,
@@ -1290,39 +778,31 @@ def picker(
         on_presented: Callable[[], None] | None = None,
     ) -> tuple[str, ...]:
         del initial_dir, accept, multiple
-        if on_presented is not None:
-            on_presented()
-        entered.set()
-        assert released.wait(timeout=2.0)
+        assert on_presented is not None
+        on_presented()
         return ()
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
     presenter = _Presenter()
-    window = NativeWindowClientWindow(
-        presenter_factory=_presenter_factory(presenter),
-        presentation_timeout_seconds=0.05,
-    )
+    window = NativeWindowClientWindow(presenter_factory=_presenter_factory(presenter))
     window.open(_session_desc())
     window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    assert entered.wait(timeout=2.0)
-    time.sleep(0.12)
-    assert window.get_user_input_events().get_events() == []
-    released.set()
-    events = _wait_for_input_events(window)
+    events: list[object] = []
+    for _ in range(100):
+        events.extend(window.get_user_input_events().get_events())
+        if len(events) >= 2:
+            break
+        time.sleep(0.01)
     window.close()
 
-    assert len(events) == 1
-    event = events[0]
-    assert isinstance(event, SelectedFilesUserInputEvent)
-    assert event.status is SelectedFilesStatus.CANCELLED
-
-
-def test_ask_open_filename_linux_requires_a_desktop_chooser(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(native_window_module.shutil, "which", lambda name: None)
-    with pytest.raises(RuntimeError, match="zenity or kdialog"):
-        native_window_module._ask_open_filename_linux(initial_dir="/tmp")
+    assert [type(event) for event in events] == [
+        FileSelectorOpenedUserInputEvent,
+        SelectedFilesUserInputEvent,
+    ]
+    assert all(
+        cast(SelectedFilesUserInputEvent, event).request_id == "open-1"
+        for event in events
+    )
 
 
 def test_native_window_reports_multiple_selected_files(
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 16dccce94..40a138941 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -11,10 +11,7 @@
 from numpy import uint64
 
 from flashdreams.api_v2.loop import IUILoop
-from flashdreams.runtime_v2.file_selection_gate import (
-    FileSelectionGate,
-    QueuedFileSelection,
-)
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
 from flashdreams.runtime_v2.null_client_window import NullClientWindow
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
@@ -31,8 +28,13 @@
     selected_files_policy_status,
 )
 from flashdreams.runtime_v2.session_desc import SessionDesc
+from flashdreams.runtime_v2.session_runner import _FileSelections
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
+from flashdreams.runtime_v2.user_input_event import (
+    CloseUserInputEvent,
+    FileSelectorOpenedUserInputEvent,
+    SelectedFilesUserInputEvent,
+)
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 pytestmark = pytest.mark.ci_cpu
@@ -137,99 +139,95 @@ def test_ui_loop_keeps_file_results_until_a_step_runs() -> None:
     assert loop.user_events.get_events() == []
 
 
-def _queued(request_id: str) -> QueuedFileSelection:
-    return QueuedFileSelection(
+class _PickerWindow(NullClientWindow):
+    def __init__(self) -> None:
+        self.started: list[str] = []
+
+    def request_selected_files(self, request: FileSelectionRequest) -> None:
+        self.started.append(request.request_id)
+
+
+class _Clock:
+    def __init__(self) -> None:
+        self.now = 0.0
+
+    def __call__(self) -> float:
+        return self.now
+
+
+def _request(request_id: str) -> FileSelectionRequest:
+    return FileSelectionRequest(request_id=request_id, initial_path="/tmp")
+
+
+def _opened(request_id: str) -> FileSelectorOpenedUserInputEvent:
+    return FileSelectorOpenedUserInputEvent(timestamp=uint64(0), request_id=request_id)
+
+
+def _result(request_id: str) -> SelectedFilesUserInputEvent:
+    return SelectedFilesUserInputEvent(
+        timestamp=uint64(0),
         request_id=request_id,
-        initial_path="/tmp",
-        accept=(".bin",),
-        max_bytes=16,
+        status=SelectedFilesStatus.CANCELLED,
     )
 
 
-def test_file_selection_gate_ignores_duplicates_and_serves_one_at_a_time() -> None:
-    gate = FileSelectionGate()
-    assert gate.submit(_queued("open-1")).started is not None
-    assert gate.submit(_queued("open-1")).started is None
-    assert gate.submit(_queued("open-2")).started is None
-    assert gate.submit(_queued("open-2")).started is None
-    assert gate.complete("open-2") == (False, None)
-    claimed, nxt = gate.complete("open-1")
-    assert claimed
-    assert nxt is not None
-    assert nxt.request_id == "open-2"
-    assert gate.complete("open-2") == (True, None)
-
-
-def test_file_selection_gate_drain_returns_active_then_queued() -> None:
-    gate = FileSelectionGate()
-    assert gate.submit(_queued("open-1")).started is not None
-    assert gate.submit(_queued("open-2")).started is None
-    claimed, nxt = gate.complete("open-1")
-    assert claimed
-    assert nxt is not None
-    assert [item.request_id for item in gate.drain()] == ["open-2"]
-    assert gate.drain() == ()
-
-
-def test_file_selection_gate_stale_complete_does_not_release_new_request() -> None:
-    gate = FileSelectionGate()
-    first = gate.submit(_queued("open-1")).started
-    assert first is not None
-    stale_generation = first.generation
-    gate.drain()
-    second = gate.submit(_queued("open-1")).started
-    assert second is not None
-    assert second.generation != stale_generation
-    assert gate.complete("open-1", generation=stale_generation) == (False, None)
-    assert gate.is_current("open-1", second.generation)
-    assert gate.complete("open-1", generation=second.generation) == (True, None)
-
-
-def test_file_selection_gate_complete_after_drain_is_not_claimed() -> None:
-    gate = FileSelectionGate()
-    first = gate.submit(_queued("open-1")).started
-    assert first is not None
-    leftover = gate.drain()
-    assert leftover[0].request_id == "open-1"
-    assert gate.complete("open-1", first.generation) == (False, None)
-
-
-def test_file_selection_gate_holds_unpresented_request_until_host_finishes() -> None:
-    gate = FileSelectionGate()
-    active = gate.submit(_queued("open-1")).started
-    assert active is not None
-    assert gate.submit(_queued("open-2")).started is None
-    expired = gate.expire_presentation(active)
-    assert [item.request_id for item in expired] == ["open-1", "open-2"]
-    assert gate.may_show(active.request_id, active.generation) is False
-    assert gate.is_current(active.request_id, active.generation)
-    refused = gate.submit(_queued("open-3"))
-    assert refused.started is None
-    assert refused.unavailable
-    assert gate.expire_presentation(active) == ()
-    assert gate.complete(active.request_id, active.generation) == (False, None)
-    assert gate.submit(_queued("open-3")).started is not None
-
-
-def test_file_selection_gate_presented_request_does_not_expire() -> None:
-    gate = FileSelectionGate()
-    active = gate.submit(_queued("open-1")).started
-    assert active is not None
-    assert gate.mark_presented(active.request_id, active.generation)
-    assert gate.expire_presentation(active) == ()
-    assert gate.complete(active.request_id, active.generation) == (True, None)
-
-
-def test_file_selection_gate_old_pick_cannot_expire_a_reused_id() -> None:
-    gate = FileSelectionGate()
-    old = gate.submit(_queued("open-1")).started
-    assert old is not None
-    assert gate.complete(old.request_id, old.generation) == (True, None)
-    new = gate.submit(_queued("open-1")).started
-    assert new is not None
-    assert (new.request_id, new.generation) == (old.request_id, old.generation)
-    assert gate.expire_presentation(old) == ()
-    assert gate.expire_presentation(new) == (new,)
+def _statuses(events: list[UserInputEvent]) -> list[tuple[str, SelectedFilesStatus]]:
+    return [
+        (event.request_id, event.status)
+        for event in events
+        if isinstance(event, SelectedFilesUserInputEvent)
+    ]
+
+
+def test_session_shows_one_picker_at_a_time() -> None:
+    window = _PickerWindow()
+    selections = _FileSelections(window, timeout_seconds=1.0, clock=_Clock())
+    assert selections.request(_request("open-1")) == []
+    assert selections.request(_request("open-1")) == []
+    busy = selections.request(_request("open-2"))
+    assert _statuses(busy) == [("open-2", SelectedFilesStatus.UNAVAILABLE)]
+    assert window.started == ["open-1"]
+
+    assert selections.filter([_result("open-2")]) == []
+    kept = selections.filter([_result("open-1")])
+    assert _statuses(kept) == [("open-1", SelectedFilesStatus.CANCELLED)]
+    assert selections.request(_request("open-2")) == []
+    assert window.started == ["open-1", "open-2"]
+
+
+def test_session_times_out_unopened_picker_and_drops_its_late_result() -> None:
+    window = _PickerWindow()
+    clock = _Clock()
+    selections = _FileSelections(window, timeout_seconds=1.0, clock=clock)
+    selections.request(_request("open-1"))
+
+    clock.now = 1.0
+    kept = selections.filter([])
+    assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
+    assert selections.filter([_result("open-1")]) == []
+    assert selections.request(_request("open-2")) == []
+    assert window.started == ["open-1", "open-2"]
+
+
+def test_session_opened_picker_waits_for_the_user_without_deadline() -> None:
+    window = _PickerWindow()
+    clock = _Clock()
+    selections = _FileSelections(window, timeout_seconds=1.0, clock=clock)
+    selections.request(_request("open-1"))
+    assert selections.filter([_opened("open-1"), _opened("other")]) == []
+
+    clock.now = 100.0
+    assert selections.filter([]) == []
+    kept = selections.filter([_result("open-1")])
+    assert _statuses(kept) == [("open-1", SelectedFilesStatus.CANCELLED)]
+
+
+def test_session_passes_through_immediate_results_and_other_input() -> None:
+    selections = _FileSelections(NullClientWindow(), clock=_Clock())
+    kept = selections.request(_request("open-1"))
+    assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
+    close = CloseUserInputEvent(timestamp=uint64(0))
+    assert selections.filter([close]) == [close]
 
 
 def test_selected_file_policy_helpers() -> None:
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index be9eaa77c..39c927782 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -36,12 +36,14 @@
     MAX_SELECTED_FILE_BYTES,
     FileSelectionRequest,
     SelectedFilesStatus,
+    clamp_selected_file_max_bytes,
 )
 from flashdreams.runtime_v2.serving import webrtc_server
 from flashdreams.runtime_v2.serving.webrtc_server import _VideoTrack
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
+    FileSelectorOpenedUserInputEvent,
     FocusUserInputEvent,
     GamepadUserInputEvent,
     GameWheelUserInputEvent,
@@ -86,6 +88,17 @@ async def _wait_file_armed(window: WebRTCClientWindow, request_id: str) -> None:
     raise AssertionError("file selection was not armed")
 
 
+def _arm(window: WebRTCClientWindow, request: FileSelectionRequest) -> None:
+    """Arm upload policy as if the browser had been sent ``request``."""
+    window.server._pending_file_requests[request.request_id] = (
+        webrtc_server._PendingFileSelection(
+            accept=request.accept,
+            max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
+            multiple=request.multiple,
+        )
+    )
+
+
 async def _post_selected_file(
     window: WebRTCClientWindow,
     request_id: str,
@@ -108,6 +121,7 @@ async def _post_selected_file(
 async def test_file_upload_accepts_multiple_files() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
+    peer, _, _ = await _connect_browser(window)
     try:
         window.request_selected_files(_file_request("open-1", multiple=True))
         await _wait_file_armed(window, "open-1")
@@ -132,6 +146,7 @@ async def test_file_upload_accepts_multiple_files() -> None:
         assert [chosen.name for chosen in event.files] == ["a.bin", "b.bin"]
         assert [chosen.data for chosen in event.files] == [b"one", b"two"]
     finally:
+        await peer.close()
         window.close()
 
 
@@ -227,52 +242,29 @@ async def test_browser_query_string_reaches_the_input_stream() -> None:
 
 
 @pytest.mark.asyncio
-async def test_browser_file_selections_are_served_one_at_a_time() -> None:
+async def test_file_selector_without_a_viewer_is_unavailable() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
         window.request_selected_files(_file_request("open-1"))
-        window.request_selected_files(_file_request("open-1"))
-        window.request_selected_files(_file_request("open-2"))
-        await _wait_file_armed(window, "open-1")
-        assert "open-2" not in window.server._pending_file_requests
-        assert await _post_selected_file(window, "open-2", b"early", "early.txt") == 409
-        assert await _post_selected_file(window, "open-1", b"first", "first.txt") == 204
-        await _wait_file_armed(window, "open-2")
-        assert (
-            await _post_selected_file(window, "open-2", b"second", "second.txt") == 204
-        )
-
-        events = []
-        for _ in range(100):
-            events.extend(window.get_user_input_events().get_events())
-            if len(events) >= 2:
-                break
-            await asyncio.sleep(0.01)
-        picks = [
-            event for event in events if isinstance(event, SelectedFilesUserInputEvent)
-        ]
-        assert [event.request_id for event in picks] == ["open-1", "open-2"]
-        assert all(event.status is SelectedFilesStatus.OK for event in picks)
-        assert picks[0].files[0].name == "first.txt"
-        assert picks[0].files[0].data == b"first"
-        assert picks[1].files[0].data == b"second"
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+        assert window.server._pending_file_requests == {}
     finally:
         window.close()
 
 
 @pytest.mark.asyncio
-async def test_peer_loss_completes_queued_file_selections_as_unavailable() -> None:
+async def test_peer_loss_completes_armed_file_selections_as_unavailable() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     peer: RTCPeerConnection | None = None
-    replacement: RTCPeerConnection | None = None
     try:
         peer, _, _ = await _connect_browser(window)
         window.request_selected_files(_file_request("open-1"))
         window.request_selected_files(_file_request("open-2"))
-        await _wait_file_armed(window, "open-1")
-        assert "open-2" not in window.server._pending_file_requests
+        await _wait_file_armed(window, "open-2")
         await peer.close()
         peer = None
 
@@ -291,21 +283,14 @@ async def test_peer_loss_completes_queued_file_selections_as_unavailable() -> No
             for event in picks
         )
         assert window.server._pending_file_requests == {}
-        assert window.server._queued_file_selectors == []
-
-        replacement, _, _ = await _connect_browser(window)
-        assert "open-2" not in window.server._pending_file_requests
-        assert window.server._queued_file_selectors == []
     finally:
         if peer is not None:
             await peer.close()
-        if replacement is not None:
-            await replacement.close()
         window.close()
 
 
 @pytest.mark.asyncio
-async def test_in_flight_upload_is_dropped_after_peer_loss(
+async def test_in_flight_upload_finishes_once_after_peer_loss(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     window = WebRTCClientWindow()
@@ -328,80 +313,13 @@ async def multipart_after_disconnect(request: web.Request) -> Any:
             return await original_multipart(request)
 
         monkeypatch.setattr(web.Request, "multipart", multipart_after_disconnect)
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
-        events = []
-        for _ in range(100):
-            events.extend(window.get_user_input_events().get_events())
-            if events:
-                break
-            await asyncio.sleep(0.01)
-        assert len(events) == 1
-        event = events[0]
-        assert isinstance(event, SelectedFilesUserInputEvent)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.UNAVAILABLE
-        assert event.files == ()
-    finally:
-        if peer is not None:
-            await peer.close()
-        window.close()
-
-
-@pytest.mark.asyncio
-async def test_stale_file_selector_arm_is_ignored_after_peer_loss(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    window = WebRTCClientWindow()
-    window.open(_session_desc())
-    peer: RTCPeerConnection | None = None
-    replacement: RTCPeerConnection | None = None
-    try:
-        peer, _, _ = await _connect_browser(window)
-        delayed: list[tuple[dict[str, Any], int]] = []
-        original_arm = window.server._arm_file_selector
-
-        def capture_arm(payload: dict[str, Any], generation: int) -> None:
-            delayed.append((payload, generation))
-
-        monkeypatch.setattr(window.server, "_arm_file_selector", capture_arm)
-        window.request_selected_files(_file_request("open-1"))
-        for _ in range(100):
-            if delayed:
-                break
-            await asyncio.sleep(0.01)
-        assert delayed
-
-        await peer.close()
-        peer = None
-        events = []
-        for _ in range(100):
-            events.extend(window.get_user_input_events().get_events())
-            if events:
-                break
-            await asyncio.sleep(0.01)
-        assert len(events) == 1
-        event = events[0]
-        assert isinstance(event, SelectedFilesUserInputEvent)
+        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
+        event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.UNAVAILABLE
-
-        payload, generation = delayed[0]
-        loop = window.server._loop
-        assert loop is not None
-        loop.call_soon_threadsafe(original_arm, payload, generation)
-        await asyncio.sleep(0.05)
-        assert window.server._pending_file_requests == {}
-        assert window.server._queued_file_selectors == []
-
-        replacement, _, _ = await _connect_browser(window)
-        await asyncio.sleep(0.05)
-        assert window.server._pending_file_requests == {}
-        assert window.server._queued_file_selectors == []
+        assert event.status is SelectedFilesStatus.OK
     finally:
         if peer is not None:
             await peer.close()
-        if replacement is not None:
-            await replacement.close()
         window.close()
 
 
@@ -485,8 +403,7 @@ async def test_file_upload_without_file_is_unavailable() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1"))
         form = FormData()
         form.add_field("not_file", "hello")
         async with ClientSession() as client:
@@ -505,8 +422,7 @@ async def test_file_upload_rejects_oversize() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(_file_request("open-1", max_bytes=1))
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1", max_bytes=1))
         status = await _post_selected_file(window, "open-1", b"x" * 8192, "big.bin")
         assert status == 413
         event = await _wait_selected_files_event(window)
@@ -525,8 +441,7 @@ async def test_file_upload_stops_once_the_batch_exceeds_its_cap(
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(_file_request("open-1", multiple=True))
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1", multiple=True))
         form = FormData()
         for name in ("a.bin", "b.bin", "c.bin"):
             form.add_field(
@@ -550,10 +465,7 @@ async def test_file_upload_over_the_batch_cap_still_reports_a_disallowed_type(
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(
-            _file_request("open-1", accept=(".bin",), multiple=True)
-        )
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1", accept=(".bin",), multiple=True))
         form = FormData()
         for name in ("a.bin", "b.bin", "c.exe"):
             form.add_field(
@@ -573,8 +485,7 @@ async def test_file_upload_decodes_base64_transfer_encoding() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1"))
         boundary = "----flashdreams"
         body = (
             f"--{boundary}\r\n"
@@ -604,10 +515,7 @@ async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(
-            _file_request("open-1", accept=(".png",), max_bytes=1)
-        )
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1", accept=(".png",), max_bytes=1))
         assert (
             await _post_selected_file(
                 window, "open-1", b"x" * (2 * 1024 * 1024), "hello.txt"
@@ -623,57 +531,25 @@ async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
 
 
 @pytest.mark.asyncio
-async def test_unsent_file_selector_times_out_and_releases_the_slot() -> None:
-    window = WebRTCClientWindow(presentation_timeout_seconds=0.05)
-    window.open(_session_desc())
-    try:
-        window.request_selected_files(_file_request("open-1"))
-        event = await _wait_selected_files_event(window)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.UNAVAILABLE
-        window.request_selected_files(_file_request("open-2"))
-        await _wait_file_armed(window, "open-2")
-    finally:
-        window.close()
-
-
-@pytest.mark.asyncio
-async def test_timeout_racing_a_disconnect_still_answers_the_request() -> None:
+async def test_browser_ack_reports_the_file_selector_opened() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
-    try:
-        window.request_selected_files(_file_request("open-1"))
-        window.request_selected_files(_file_request("open-2"))
-        active = window._file_gate._active
-        assert active is not None
-        expired = window._file_gate.expire_presentation(active)
-        window._invalidate_file_selections(True)
-        window._on_file_selection_unpresented(expired)
-        events = window.get_user_input_events().get_events()
-        assert [
-            (event.request_id, event.status)
-            for event in events
-            if isinstance(event, SelectedFilesUserInputEvent)
-        ] == [
-            ("open-1", SelectedFilesStatus.UNAVAILABLE),
-            ("open-2", SelectedFilesStatus.UNAVAILABLE),
-        ]
-    finally:
-        window.close()
-
-
-@pytest.mark.asyncio
-async def test_acknowledged_file_selector_waits_past_the_deadline() -> None:
-    window = WebRTCClientWindow(presentation_timeout_seconds=0.3)
-    window.open(_session_desc())
     peer: RTCPeerConnection | None = None
     try:
         peer, channel, _ = await _connect_browser(window)
         window.request_selected_files(_file_request("open-1"))
         await _wait_file_armed(window, "open-1")
+        channel.send(json.dumps({"type": "file_selector_ack", "id": "other"}))
         channel.send(json.dumps({"type": "file_selector_ack", "id": "open-1"}))
-        await asyncio.sleep(0.45)
-        assert window.get_user_input_events().get_events() == []
+        opened: list[object] = []
+        for _ in range(100):
+            opened.extend(window.get_user_input_events().get_events())
+            if opened:
+                break
+            await asyncio.sleep(0.01)
+        assert len(opened) == 1
+        assert isinstance(opened[0], FileSelectorOpenedUserInputEvent)
+        assert opened[0].request_id == "open-1"
         channel.send(
             json.dumps(
                 {
@@ -692,52 +568,6 @@ async def test_acknowledged_file_selector_waits_past_the_deadline() -> None:
         window.close()
 
 
-@pytest.mark.asyncio
-async def test_sent_file_selector_without_ack_discards_a_late_result() -> None:
-    window = WebRTCClientWindow(presentation_timeout_seconds=0.2)
-    window.open(_session_desc())
-    peer: RTCPeerConnection | None = None
-    try:
-        peer, channel, _ = await _connect_browser(window)
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
-        for _ in range(50):
-            if any(
-                request_id == "open-1"
-                for request_id, _generation in window.server._file_selector_sent
-            ):
-                break
-            await asyncio.sleep(0.01)
-        assert any(
-            request_id == "open-1"
-            for request_id, _generation in window.server._file_selector_sent
-        )
-        event = await _wait_selected_files_event(window)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.UNAVAILABLE
-        window.request_selected_files(_file_request("open-2"))
-        refused = await _wait_selected_files_event(window)
-        assert refused.request_id == "open-2"
-        assert refused.status is SelectedFilesStatus.UNAVAILABLE
-        channel.send(
-            json.dumps(
-                {
-                    "type": "file_selector_result",
-                    "id": "open-1",
-                    "status": "cancelled",
-                }
-            )
-        )
-        await asyncio.sleep(0.05)
-        assert window.get_user_input_events().get_events() == []
-        window.request_selected_files(_file_request("open-3"))
-        await _wait_file_armed(window, "open-3")
-    finally:
-        if peer is not None:
-            await peer.close()
-        window.close()
-
-
 @pytest.mark.asyncio
 async def test_browser_file_selector_result_reports_status() -> None:
     window = WebRTCClientWindow()
@@ -837,55 +667,10 @@ async def test_session_handoff_clears_pending_file_selection() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        _arm(window, _file_request("open-1"))
         window.open(_session_desc())
-        assert "open-1" not in window.server._pending_file_requests
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
-    finally:
-        window.close()
-
-
-@pytest.mark.asyncio
-async def test_in_flight_upload_is_dropped_after_session_handoff(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    window = WebRTCClientWindow()
-    window.open(_session_desc())
-    try:
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
-        original_multipart = web.Request.multipart
-        handed_off = False
-
-        async def multipart_after_handoff(request: web.Request) -> Any:
-            nonlocal handed_off
-            if not handed_off:
-                handed_off = True
-                window.open(_session_desc())
-            return await original_multipart(request)
-
-        monkeypatch.setattr(web.Request, "multipart", multipart_after_handoff)
+        assert window.server._pending_file_requests == {}
         assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
-        assert window.get_user_input_events().get_events() == []
-
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
-        assert await _post_selected_file(window, "open-1", b"next", "next.txt") == 204
-        events = []
-        for _ in range(100):
-            events.extend(window.get_user_input_events().get_events())
-            if events:
-                break
-            await asyncio.sleep(0.01)
-        assert len(events) == 1
-        event = events[0]
-        assert isinstance(event, SelectedFilesUserInputEvent)
-        assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.OK
-        assert event.files[0].data == b"next"
     finally:
         window.close()
 
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index c94a1797e..ae7ad0755 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -9,14 +9,14 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
 
 - `imgui-ui-text-input` renders an editable text field over model output.
 - `imgui-ui-file-picker` opens the client file selector and shows the chosen
-  name and size. Each Open button calls `file_selector` every UI tick with
-  a stable `request_id`; the returned event carries the file bytes. Extra
-  clicks on the same button while a picker is open are ignored;
-  **Open A then B** queues both selectors one at a time. Closing the native
-  window or dropping the WebRTC tab completes leftover and in-flight picks
-  as unavailable. A picker the host never shows within 30 seconds also
-  completes as unavailable; a picker that is shown stays open as long as the
-  user wants.
+  name and size on one status line per button. Each Open button calls
+  `file_selector` every UI tick with its own stable `request_id`; the returned
+  event carries the file bytes. Extra
+  clicks on the same button while a picker is open are ignored. One picker is
+  open at a time; opening another meanwhile reports it as unavailable.
+  Dropping the WebRTC tab completes in-flight picks as unavailable. A picker
+  the host never shows within 30 seconds also completes as unavailable; a
+  picker that is shown stays open as long as the user wants.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
 - `imgui-ui-window-size` resizes native window or UI render target without
   resetting session.
@@ -33,11 +33,11 @@ Run the text-input application:
 uv run --no-sync flashdreams-run-v2 imgui-ui-text-input --mode native-window
 ```
 
-Run the file-picker application. Native Linux needs `zenity` or `kdialog`
-(the desktop portal picker). Windows and macOS use Tk. WebRTC shows a
+Run the file-picker application. The native window uses the Tk file dialog
+(on Linux, install Python's Tk package, such as `python3-tk`). WebRTC shows a
 confirmation dialog in the viewer (the picker must open from a browser click).
 The demo asks for `.bin` / `.raw` at the per-file ceiling
-(`MAX_SELECTED_FILE_BYTES`). Controls are **Open file (A)**, **Open file (B)**, **Open A then B**, and **Open files**
+(`MAX_SELECTED_FILE_BYTES`). Controls are **Open file (A)**, **Open file (B)**, and **Open files**
 (more than one file). Failed picks show in red with the
 `SelectedFilesStatus` name and why.
 ```bash
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index ae279b615..3a4838feb 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -5,7 +5,7 @@
 
 import math
 from collections.abc import Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 
 import torch
@@ -47,17 +47,18 @@
     ),
     SelectedFilesStatus.UNAVAILABLE: (
         "SelectedFilesStatus.UNAVAILABLE: picker could not complete "
-        "(no interactive client, gone client, failed chooser, or unreadable file)."
+        "(another picker open, no or gone client, failed chooser, or "
+        "unreadable file)."
     ),
 }
 _FILE_SELECTION_ERROR_COLOR = (1.0, 0.25, 0.25, 1.0)
 """RGBA used for cancelled and other failed selector results."""
 
 _OPEN_FILE_A_REQUEST_ID = "open-file-a"
-"""Selector slot for Open file (A). Mash uses this same id."""
+"""Selector slot for Open file (A)."""
 
 _OPEN_FILE_B_REQUEST_ID = "open-file-b"
-"""Selector slot for Open file (B). Queued behind A when both are requested."""
+"""Selector slot for Open file (B)."""
 
 _OPEN_FILE_A_LABEL = "Open file (A)"
 """ImGui label for selector slot A."""
@@ -65,15 +66,22 @@
 _OPEN_FILE_B_LABEL = "Open file (B)"
 """ImGui label for selector slot B."""
 
-_OPEN_A_THEN_B_LABEL = "Open A then B"
-"""ImGui label that requests A then B in the same UI tick."""
-
 _OPEN_FILES_REQUEST_ID = "open-files"
 """Selector slot for Open files. Asks for more than one file."""
 
 _OPEN_FILES_LABEL = "Open files"
 """ImGui label for a multi-file selector slot."""
 
+_FILE_SELECTOR_SLOTS = (
+    (_OPEN_FILE_A_LABEL, _OPEN_FILE_A_REQUEST_ID, False),
+    (_OPEN_FILE_B_LABEL, _OPEN_FILE_B_REQUEST_ID, False),
+    (_OPEN_FILES_LABEL, _OPEN_FILES_REQUEST_ID, True),
+)
+"""``(label, request_id, multiple)`` for each Open button, in display order."""
+
+_NO_FILE_SELECTED = "No file selected."
+"""Status shown for a button before its first result."""
+
 
 class BreathingBackgroundModelLoop(IModelLoop[tuple[SessionDesc, torch.device | str]]):
     """Generate a black-to-gray breathing background for the file-picker demo."""
@@ -107,14 +115,23 @@ def reset(self) -> None:
 
 @dataclass(slots=True)
 class FilePickerState:
-    """Last file-selector result shown by the demo overlay."""
+    """Last file-selector result for each Open button."""
+
+    statuses: dict[str, str] = field(default_factory=dict)
+    """Status text by ``request_id``. A missing id has no result yet."""
 
-    status: str = "No file selected."
-    """Human-readable status of the last selector result."""
+
+def _status_text(event: SelectedFilesUserInputEvent) -> str:
+    """Return the overlay text for one selector result."""
+    if event.status is not SelectedFilesStatus.OK:
+        return _FILE_SELECTION_STATUS_TEXT[event.status]
+    return ", ".join(
+        f"{chosen.name} ({len(chosen.data)} bytes)" for chosen in event.files
+    )
 
 
 class FilePickerImGuiUILoop(ImGuiUILoop[FilePickerState]):
-    """Request a ``.bin`` / ``.raw`` pick and show the chosen name and size."""
+    """Request ``.bin`` / ``.raw`` picks and show each button's own result."""
 
     def step_ui(
         self,
@@ -122,80 +139,46 @@ def step_ui(
         step_index: int,
         events: UserInputEvents,
     ) -> Tensor | None:
-        """Draw the Open-file controls and apply this tick's selector results."""
+        """Draw the Open buttons and one status line per button."""
         del step_index, events
         imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
         imgui.set_next_window_size(imgui.ImVec2(520.0, 300.0), imgui.Cond_.once)
         imgui.begin("File picker")
         try:
-            clicked_a = imgui.button(_OPEN_FILE_A_LABEL)
-            clicked_b = imgui.button(_OPEN_FILE_B_LABEL)
-            clicked_a_then_b = imgui.button(_OPEN_A_THEN_B_LABEL)
-            clicked_files = imgui.button(_OPEN_FILES_LABEL)
-            self._apply_demo_pick(
-                self._request_demo_file(
-                    _OPEN_FILE_A_REQUEST_ID,
-                    open=clicked_a or clicked_a_then_b,
-                )
-            )
-            self._apply_demo_pick(
-                self._request_demo_file(
-                    _OPEN_FILE_B_REQUEST_ID,
-                    open=clicked_b or clicked_a_then_b,
+            clicked = [imgui.button(label) for label, _, _ in _FILE_SELECTOR_SLOTS]
+            for (_, request_id, multiple), pressed in zip(
+                _FILE_SELECTOR_SLOTS, clicked, strict=True
+            ):
+                pick = self.file_selector(
+                    request_id,
+                    open=pressed,
+                    accept=(".bin", ".raw"),
+                    max_file_bytes=MAX_SELECTED_FILE_BYTES,
+                    multiple=multiple,
                 )
-            )
-            self._apply_demo_pick(
-                self._request_demo_file(
-                    _OPEN_FILES_REQUEST_ID,
-                    open=clicked_files,
-                    multiple=True,
-                )
-            )
-            if self.state.status in _FILE_SELECTION_STATUS_TEXT.values():
+                if pick is not None:
+                    self.state.statuses[request_id] = _status_text(pick)
+            for label, request_id, _ in _FILE_SELECTOR_SLOTS:
+                status = self.state.statuses.get(request_id, _NO_FILE_SELECTED)
+                line = f"{label}: {status}"
+                if status not in _FILE_SELECTION_STATUS_TEXT.values():
+                    imgui.text(line)
+                    continue
                 imgui.push_style_color(
                     imgui.Col_.text,
                     imgui.ImVec4(*_FILE_SELECTION_ERROR_COLOR),
                 )
                 try:
-                    imgui.text_wrapped(self.state.status)
+                    imgui.text_wrapped(line)
                 finally:
                     imgui.pop_style_color()
-            else:
-                imgui.text(self.state.status)
         finally:
             imgui.end()
         return self.presented_model_frame()
 
-    def _request_demo_file(
-        self,
-        request_id: str,
-        *,
-        open: bool,
-        multiple: bool = False,
-    ) -> SelectedFilesUserInputEvent | None:
-        """Poll one ``.bin`` / ``.raw`` selector slot and optionally start it."""
-        return self.file_selector(
-            request_id,
-            open=open,
-            accept=(".bin", ".raw"),
-            max_file_bytes=MAX_SELECTED_FILE_BYTES,
-            multiple=multiple,
-        )
-
-    def _apply_demo_pick(self, event: SelectedFilesUserInputEvent | None) -> None:
-        """Show this tick's selector result on the overlay."""
-        if event is None:
-            return
-        if event.status is not SelectedFilesStatus.OK:
-            self.state.status = _FILE_SELECTION_STATUS_TEXT[event.status]
-            return
-        self.state.status = ", ".join(
-            f"{chosen.name} ({len(chosen.data)} bytes)" for chosen in event.files
-        )
-
     def reset(self) -> None:
-        """Clear the last selector result for a new generation."""
-        self.state.status = "No file selected."
+        """Clear every button's result for a new generation."""
+        self.state.statuses.clear()
         super().reset()
 
 
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 5f38b774b..8ab6d52db 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -12,7 +12,6 @@
 from imgui_ui_demo.file_picker_app import (
     _FILE_SELECTION_ERROR_COLOR,
     _FILE_SELECTION_STATUS_TEXT,
-    _OPEN_A_THEN_B_LABEL,
     _OPEN_FILE_A_LABEL,
     _OPEN_FILE_A_REQUEST_ID,
     _OPEN_FILE_B_LABEL,
@@ -141,20 +140,6 @@ def test_open_files_button_requests_multiple_client_files() -> None:
     assert requests.file_selections[0].multiple is True
 
 
-def test_open_a_then_b_queues_both_request_ids() -> None:
-    _state, loop = _file_picker_loop()
-    imgui = _file_picker_imgui(pressed=_OPEN_A_THEN_B_LABEL)
-
-    loop.step_ui(imgui, 0, UserInputEvents([]))
-    requests = loop.flush_ui_loop_requests()
-
-    assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == [
-        _OPEN_FILE_A_REQUEST_ID,
-        _OPEN_FILE_B_REQUEST_ID,
-    ]
-
-
 def test_selected_files_event_updates_file_picker_status() -> None:
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()
@@ -171,12 +156,43 @@ def test_selected_files_event_updates_file_picker_status() -> None:
     )
     loop.step_ui(imgui, 0, loop.user_events)
 
-    assert state.status == "seed.png (2 bytes)"
-    imgui.text.assert_called_with("seed.png (2 bytes)")
+    assert state.statuses == {_OPEN_FILE_A_REQUEST_ID: "seed.png (2 bytes)"}
+    assert [call.args[0] for call in imgui.text.call_args_list] == [
+        f"{_OPEN_FILE_A_LABEL}: seed.png (2 bytes)",
+        f"{_OPEN_FILE_B_LABEL}: No file selected.",
+        f"{_OPEN_FILES_LABEL}: No file selected.",
+    ]
     imgui.text_wrapped.assert_not_called()
     imgui.push_style_color.assert_not_called()
 
 
+def test_each_button_shows_only_its_own_result() -> None:
+    state, loop = _file_picker_loop()
+    loop.user_events = UserInputEvents(
+        [
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=_OPEN_FILE_B_REQUEST_ID,
+                status=SelectedFilesStatus.OK,
+                files=(SelectedFile(name="b.bin", data=b"b"),),
+            ),
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=_OPEN_FILES_REQUEST_ID,
+                status=SelectedFilesStatus.UNAVAILABLE,
+            ),
+        ]
+    )
+    loop.step_ui(_file_picker_imgui(), 0, loop.user_events)
+
+    assert state.statuses == {
+        _OPEN_FILE_B_REQUEST_ID: "b.bin (1 bytes)",
+        _OPEN_FILES_REQUEST_ID: _FILE_SELECTION_STATUS_TEXT[
+            SelectedFilesStatus.UNAVAILABLE
+        ],
+    }
+
+
 def test_selected_files_event_lists_every_chosen_file() -> None:
     state, loop = _file_picker_loop()
     imgui = _file_picker_imgui()
@@ -196,8 +212,12 @@ def test_selected_files_event_lists_every_chosen_file() -> None:
     )
     loop.step_ui(imgui, 0, loop.user_events)
 
-    assert state.status == "a.bin (2 bytes), b.raw (3 bytes)"
-    imgui.text.assert_called_with("a.bin (2 bytes), b.raw (3 bytes)")
+    assert state.statuses == {
+        _OPEN_FILES_REQUEST_ID: "a.bin (2 bytes), b.raw (3 bytes)"
+    }
+    imgui.text.assert_called_with(
+        f"{_OPEN_FILES_LABEL}: a.bin (2 bytes), b.raw (3 bytes)"
+    )
     imgui.text_wrapped.assert_not_called()
     imgui.push_style_color.assert_not_called()
 
@@ -222,8 +242,8 @@ def test_file_picker_shows_error_status_in_red() -> None:
     loop.step_ui(imgui, 0, loop.user_events)
 
     message = _FILE_SELECTION_STATUS_TEXT[cancelled]
-    assert state.status == message
-    imgui.push_style_color.assert_called_with("text", _FILE_SELECTION_ERROR_COLOR)
-    imgui.text_wrapped.assert_called_with(message)
+    assert state.statuses == {_OPEN_FILE_A_REQUEST_ID: message}
+    imgui.push_style_color.assert_called_once_with("text", _FILE_SELECTION_ERROR_COLOR)
+    imgui.text_wrapped.assert_called_once_with(f"{_OPEN_FILE_A_LABEL}: {message}")
     imgui.pop_style_color.assert_called_once_with()
-    imgui.text.assert_not_called()
+    assert imgui.text.call_count == 2

From 6a4171e7619e1d84042b3aa98aa84c936c535ccc Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 16:56:02 -0700
Subject: [PATCH 36/43] Keep _apply_window_requests unchanged and drop the
 per-tick request_id check

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/loop.py        | 12 +-----
 .../flashdreams/runtime_v2/session_runner.py  | 39 +++++++------------
 flashdreams/test_v2/test_selected_files.py    | 38 +++++++-----------
 3 files changed, 32 insertions(+), 57 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 018e9f6e3..e75b8974f 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -536,7 +536,6 @@ def register_session_ui_loop_objects(
         self._presentation_manager = presentation_manager
 
         self._ui_loop_requests: UILoopRequests | None = None
-        self._file_selector_ids: set[str] = set()
 
     @final
     def _set_model_loop(self, model_loop: IModelLoop[Any]) -> None:
@@ -648,9 +647,8 @@ def file_selector(
             TypeError: ``request_id`` or ``initial_path`` is not a string, or
                 ``open`` / ``accept`` / ``max_file_bytes`` / ``multiple`` has
                 the wrong type.
-            ValueError: ``request_id`` is empty or already used this tick,
-                ``initial_path`` is empty, or ``accept`` / ``max_file_bytes``
-                is invalid.
+            ValueError: ``request_id`` or ``initial_path`` is empty, or
+                ``accept`` / ``max_file_bytes`` is invalid.
         """
         if not isinstance(request_id, str):
             raise TypeError("request_id must be a string.")
@@ -658,10 +656,6 @@ def file_selector(
             raise ValueError("request_id must be a non-empty string.")
         if not isinstance(open, bool):
             raise TypeError("open must be a bool.")
-        if request_id in self._file_selector_ids:
-            raise ValueError(
-                f"request_id {request_id!r} is used more than once this tick."
-            )
         if open:
             if initial_path is None:
                 resolved_initial_path = str(Path.home())
@@ -690,7 +684,6 @@ def file_selector(
                     multiple=multiple,
                 )
             )
-        self._file_selector_ids.add(request_id)
         for event in self.user_events.get_events():
             if (
                 isinstance(event, SelectedFilesUserInputEvent)
@@ -708,7 +701,6 @@ def flush_ui_loop_requests(self) -> UILoopRequests | None:
         """return UI loop requests and clear the internal state of requests."""
         requests = self._ui_loop_requests
         self._ui_loop_requests = None
-        self._file_selector_ids.clear()
         return requests
 
     @final
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 67e39d8df..44d141262 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -84,14 +84,15 @@ def __init__(
         self._clock = clock
         self._active: FileSelectionRequest | None = None
         self._deadline: float | None = None
+        self._ready: list[UserInputEvent] = []
 
-    def request(self, request: FileSelectionRequest) -> list[UserInputEvent]:
-        """Start ``request`` and return any result known right away."""
+    def request(self, request: FileSelectionRequest) -> None:
+        """Start ``request``; a result known right away is held for :meth:`filter`."""
         active = self._active
         if active is not None:
-            if active.request_id == request.request_id:
-                return []
-            return [self._unavailable(request)]
+            if active.request_id != request.request_id:
+                self._ready.append(self._unavailable(request))
+            return
         self._active = request
         self._deadline = self._clock() + self._timeout_seconds
         try:
@@ -99,14 +100,13 @@ def request(self, request: FileSelectionRequest) -> list[UserInputEvent]:
         except Exception:
             _LOGGER.exception("File selector %r failed to start.", request.request_id)
             result = self._unavailable(request)
-        if result is None:
-            return []
-        self._active = None
-        return [result]
+        if result is not None:
+            self._active = None
+            self._ready.append(result)
 
     def filter(self, events: list[UserInputEvent]) -> list[UserInputEvent]:
         """Apply window file events and the deadline; return events for the loops."""
-        kept: list[UserInputEvent] = []
+        kept, self._ready = self._ready, []
         for event in events:
             active = self._active
             if isinstance(event, FileSelectorOpenedUserInputEvent):
@@ -295,9 +295,9 @@ def run_ui_once(*, step_requested: bool = True) -> None:
 
                 request = ui_loop.flush_ui_loop_requests()
                 if request is not None:
-                    immediate = _apply_window_requests(window, request, file_selections)
-                    if immediate:
-                        event_buffer.append(UserInputEvents(immediate))
+                    _apply_window_requests(window, request)
+                    for item in request.file_selections:
+                        file_selections.request(item)
                     if request.new_session is not None:
                         next_session_desc = request.new_session
                         stop.set()
@@ -538,23 +538,14 @@ def should_end_ui() -> bool:
     return next_session_desc
 
 
-def _apply_window_requests(
-    window: IClientWindow,
-    request: UILoopRequests,
-    file_selections: _FileSelections,
-) -> list[UserInputEvent]:
-    """Apply UI window settings in request order; return immediate file results."""
+def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> None:
+    """Apply UI window settings in request order."""
     if request.hide_cursor is not None:
         window.request_hide_cursor(request.hide_cursor)
     if request.lock_cursor_to_window is not None:
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
-    return [
-        result
-        for item in request.file_selections
-        for result in file_selections.request(item)
-    ]
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 40a138941..730e0207b 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -86,19 +86,6 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     assert selection.multiple is True
 
 
-def test_ui_loop_rejects_request_id_reused_in_one_tick() -> None:
-    loop = _ui_loop()
-    loop.file_selector("open-1")
-    with pytest.raises(ValueError, match="more than once this tick"):
-        loop.file_selector("open-1", open=True)
-
-    loop.flush_ui_loop_requests()
-    loop.file_selector("open-1", open=True)
-    requests = loop.flush_ui_loop_requests()
-    assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == ["open-1"]
-
-
 def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
     loop = _ui_loop()
     loop.file_selector("open-1", open=True)
@@ -182,16 +169,16 @@ def _statuses(events: list[UserInputEvent]) -> list[tuple[str, SelectedFilesStat
 def test_session_shows_one_picker_at_a_time() -> None:
     window = _PickerWindow()
     selections = _FileSelections(window, timeout_seconds=1.0, clock=_Clock())
-    assert selections.request(_request("open-1")) == []
-    assert selections.request(_request("open-1")) == []
-    busy = selections.request(_request("open-2"))
-    assert _statuses(busy) == [("open-2", SelectedFilesStatus.UNAVAILABLE)]
+    selections.request(_request("open-1"))
+    selections.request(_request("open-1"))
+    selections.request(_request("open-2"))
     assert window.started == ["open-1"]
+    busy = selections.filter([_result("open-2")])
+    assert _statuses(busy) == [("open-2", SelectedFilesStatus.UNAVAILABLE)]
 
-    assert selections.filter([_result("open-2")]) == []
     kept = selections.filter([_result("open-1")])
     assert _statuses(kept) == [("open-1", SelectedFilesStatus.CANCELLED)]
-    assert selections.request(_request("open-2")) == []
+    selections.request(_request("open-2"))
     assert window.started == ["open-1", "open-2"]
 
 
@@ -205,7 +192,7 @@ def test_session_times_out_unopened_picker_and_drops_its_late_result() -> None:
     kept = selections.filter([])
     assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
     assert selections.filter([_result("open-1")]) == []
-    assert selections.request(_request("open-2")) == []
+    selections.request(_request("open-2"))
     assert window.started == ["open-1", "open-2"]
 
 
@@ -224,10 +211,15 @@ def test_session_opened_picker_waits_for_the_user_without_deadline() -> None:
 
 def test_session_passes_through_immediate_results_and_other_input() -> None:
     selections = _FileSelections(NullClientWindow(), clock=_Clock())
-    kept = selections.request(_request("open-1"))
-    assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
+    selections.request(_request("open-1"))
     close = CloseUserInputEvent(timestamp=uint64(0))
-    assert selections.filter([close]) == [close]
+    kept = selections.filter([close])
+    assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
+    assert kept[-1] is close
+    selections.request(_request("open-2"))
+    assert _statuses(selections.filter([])) == [
+        ("open-2", SelectedFilesStatus.UNAVAILABLE)
+    ]
 
 
 def test_selected_file_policy_helpers() -> None:

From 6d098da40c0d72cfad7d9b0aba49bee3d59fa3a7 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Tue, 13 Oct 2026 17:05:20 -0700
Subject: [PATCH 37/43] Drop the removed per-tick request_id check from the API
 README

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index a57ff7592..2a8978a8c 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -231,7 +231,7 @@ Pass `open=True` only when the user asks to open it on that tick (for ImGui,
 `SelectedFilesUserInputEvent` for that id, or `None`. Read `status`; use
 `files` only when the pick succeeded. Reuse that `request_id` so extra clicks
 do not stack pickers; use a different id for every other place that can open
-one. Using an id twice in one tick raises `ValueError`. `accept` is filename suffixes (empty = any type);
+one. `accept` is filename suffixes (empty = any type);
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in

From 7ee35990e31864d6a00f23002224ab613fa70eee Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Wed, 14 Oct 2026 09:58:55 -0700
Subject: [PATCH 38/43] Document why request_id is app-supplied and must not be
 shared

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md |  7 ++++++-
 flashdreams/flashdreams/api_v2/loop.py   | 13 +++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 2a8978a8c..eff51bb57 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -231,7 +231,12 @@ Pass `open=True` only when the user asks to open it on that tick (for ImGui,
 `SelectedFilesUserInputEvent` for that id, or `None`. Read `status`; use
 `files` only when the pick succeeded. Reuse that `request_id` so extra clicks
 do not stack pickers; use a different id for every other place that can open
-one. `accept` is filename suffixes (empty = any type);
+one. Sharing an id between places is not supported: a pick made from one
+place would also be reported to the other. The app supplies the id because
+`file_selector` is called anew every tick, so nothing persists between the
+tick that opens a picker and the tick that receives its result; like an ImGui
+widget id, the stable `request_id` is what connects them. An id generated per
+call would differ on every tick. `accept` is filename suffixes (empty = any type);
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index e75b8974f..ad1b1c3d5 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -613,9 +613,12 @@ def file_selector(
         Call every UI tick from each place in the UI that can open a picker.
         Pass ``open=True`` only on the tick that the user asks to open it, such
         as when an ImGui button returns ``True``. Use a different stable
-        ``request_id`` for each such place. One picker is open at a time:
-        another ``open=True`` for the open ``request_id`` is ignored, and one
-        for any other id completes as ``UNAVAILABLE``.
+        ``request_id`` for each such place. Sharing an id between places is
+        not supported: a pick made from one place would also be reported to
+        the other.
+        One picker is open at a time: another ``open=True`` for the open
+        ``request_id`` is ignored, and one for any other id completes as
+        ``UNAVAILABLE``.
 
         Example:
 
@@ -627,7 +630,9 @@ def file_selector(
 
         Args:
             request_id: Stable id for this place in the UI. Echoed on the
-                matching event.
+                matching event. Supplied by the app, like an ImGui widget id,
+                because it must stay the same across the ticks between
+                opening a picker and receiving its result.
             initial_path: Directory hint for the selector; ``None`` uses the
                 current user's home directory.
             open: Whether to start a selector this tick.

From 938cb4dac7945c73b2952f77d95cc8f6428ef16a Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Wed, 14 Oct 2026 18:25:42 -0700
Subject: [PATCH 39/43] Move file selection rules into IClientWindow

IClientWindow allows one picker at a time, times out a picker not shown
within 30 seconds, and creates every result event. Windows only show the
picker and report back. The session runner forwards requests and forgets
the open picker when a session ends. IUILoop.request_file_selector queues
a request; the result arrives as a SelectedFilesUserInputEvent.

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  22 +-
 .../flashdreams/api_v2/client_window.py       | 168 +++++++++++++--
 flashdreams/flashdreams/api_v2/loop.py        | 110 ++++------
 flashdreams/flashdreams/runtime_v2/README.md  |  14 ++
 .../runtime_v2/mp4_client_window.py           |  12 +-
 .../runtime_v2/native_window_client_window.py |  35 ++-
 .../runtime_v2/null_client_window.py          |  14 +-
 .../flashdreams/runtime_v2/selected_file.py   |   4 +-
 .../runtime_v2/serving/webrtc_server.py       |  81 ++++---
 .../flashdreams/runtime_v2/session_runner.py  | 110 +---------
 .../runtime_v2/user_input_event.py            |  20 +-
 .../runtime_v2/webrtc_client_window.py        |  23 +-
 .../test_native_window_client_window.py       |  43 ++--
 flashdreams/test_v2/test_selected_files.py    | 203 ++++++++----------
 flashdreams/test_v2/test_session_runner.py    |  35 +--
 .../test_v2/test_webrtc_client_window.py      | 128 +++++------
 integrations_v2/imgui_ui_demo/README.md       |   8 +-
 .../imgui_ui_demo/file_picker_app.py          |  28 ++-
 18 files changed, 536 insertions(+), 522 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index eff51bb57..219d4ac9b 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -224,24 +224,18 @@ UI control that needs a fresh application session calls
 `request_new_session(session_desc)` with a fully resolved replacement
 description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. Remaining timeout and remaining model steps
-still apply to the replacement. Call `file_selector` every UI tick from each
-place in the UI that can open a client file picker, using a stable `request_id`.
-Pass `open=True` only when the user asks to open it on that tick (for ImGui,
-`open=imgui.button(...)`). The call returns this tick's
-`SelectedFilesUserInputEvent` for that id, or `None`. Read `status`; use
-`files` only when the pick succeeded. Reuse that `request_id` so extra clicks
-do not stack pickers; use a different id for every other place that can open
-one. Sharing an id between places is not supported: a pick made from one
-place would also be reported to the other. The app supplies the id because
-`file_selector` is called anew every tick, so nothing persists between the
-tick that opens a picker and the tick that receives its result; like an ImGui
-widget id, the stable `request_id` is what connects them. An id generated per
-call would differ on every tick. `accept` is filename suffixes (empty = any type);
+still apply to the replacement. To let the user pick a client file, call
+`request_file_selector(request_id, ...)` when they ask (for ImGui, when
+`imgui.button(...)` returns `True`). The result arrives on a later tick as one
+`SelectedFilesUserInputEvent` in the UI loop's events, carrying that
+`request_id`, so each place that can open a picker should pass its own id. Read
+`status`; use `files` only when the pick succeeded. `accept` is filename
+suffixes (empty = any type);
 `max_file_bytes` is the size budget per file (`None` = the
 `MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
 the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
 `runtime_v2/selected_file.py`. One picker is open at a time; a request made
-while another is open completes as `UNAVAILABLE`. The status is also
+while another is open is ignored and gets no result. The status is
 `UNAVAILABLE` when the client cannot show a picker, or does not show one within
 30 seconds. Once a picker is shown, the user may take as long as they want.
 
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index dbbe79cdc..17d82e316 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -3,18 +3,28 @@
 
 """Client window abstract interface."""
 
+import logging
+import threading
+import time
 from abc import ABC
+from collections.abc import Callable
+from typing import final
 
 from numpy import uint64
 
 from flashdreams.runtime_v2.selected_file import (
+    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
     FileSelectionRequest,
+    SelectedFile,
     SelectedFilesStatus,
 )
 from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 
 from .input_source import InputSource
 from .output_sink import OutputSink
+from .user_input_event import UserInputEvent
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class IClientWindow(InputSource, OutputSink, ABC):
@@ -55,31 +65,145 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         pass
 
-    # Optional to implement
-    def request_selected_files(
-        self, request: FileSelectionRequest
-    ) -> SelectedFilesUserInputEvent | None:
-        """Request to open a file selector local to the client this window drives.
-
-        Every request gets exactly one result. Return it now, or return
-        ``None`` and deliver it later through
-        :meth:`InputSource.get_user_input_events`. The default has no
-        selector and returns ``UNAVAILABLE``.
-
-        Do not block. Deliver a ``FileSelectorOpenedUserInputEvent`` once the
-        picker is shown, then the result when the user finishes. The runtime
-        sends one request at a time and answers ``UNAVAILABLE`` itself if the
-        picker is not shown in time. Answer ``UNAVAILABLE`` when the host
-        cannot show a picker.
+    # File selection. The public methods below hold the rules: one picker at a
+    # time, a deadline until the picker is shown, and one result per request.
+    # A window with a picker implements the ``_request_file_selector`` hook and
+    # reports through ``_file_selector_opened`` and ``_complete_file_selector``.
+    # A window that wraps another overrides the public methods to forward them.
+
+    # Plain class defaults so subclasses need no constructor call; assigning
+    # one on an instance shadows it for that window only.
+    _active_file_selector: tuple[int, FileSelectionRequest] | None = None
+    _file_selector_deadline: float | None = None
+    _last_file_selector_id = 0
+    _file_selector_clock: Callable[[], float] = staticmethod(time.monotonic)
+
+    def request_file_selector(self, request: FileSelectionRequest) -> None:
+        """Show a file selector; its result arrives later as an input event.
+
+        The result is one ``SelectedFilesUserInputEvent`` from
+        :meth:`InputSource.get_user_input_events` carrying
+        ``request.request_id``. While a picker is open, another request is
+        ignored. A picker not shown within
+        :data:`FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS` completes as
+        ``UNAVAILABLE``; once shown, the user may take as long as they want.
 
         Args:
             request: Selector request queued by the UI loop.
+        """
+        self._expire_file_selectors()
+        with _FILE_SELECTOR_LOCK:
+            if self._active_file_selector is not None:
+                return
+            selector_id = self._last_file_selector_id + 1
+            self._last_file_selector_id = selector_id
+            self._active_file_selector = (selector_id, request)
+            self._file_selector_deadline = (
+                self._file_selector_clock()
+                + FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
+            )
+        try:
+            self._request_file_selector(selector_id, request)
+        except Exception:
+            _LOGGER.exception("File selector %r failed to start.", request.request_id)
+            self._complete_file_selector(selector_id, SelectedFilesStatus.UNAVAILABLE)
+
+    def flush_file_selectors(self) -> None:
+        """Forget the open picker without a result, for a session that ended.
+
+        A picker still on screen stays there; whatever it returns is dropped.
+        """
+        with _FILE_SELECTOR_LOCK:
+            active = self._active_file_selector
+            self._active_file_selector = None
+            self._file_selector_deadline = None
+        if active is not None:
+            self._cancel_active_file_selectors()
+
+    # Optional to implement
+    def _request_file_selector(
+        self, selector_id: int, request: FileSelectionRequest
+    ) -> None:
+        """Show a picker for ``request`` without blocking.
+
+        Call :meth:`_file_selector_opened` once it is shown, then
+        :meth:`_complete_file_selector` with ``selector_id`` when the user
+        finishes, from any thread. The default has no picker and completes as
+        ``UNAVAILABLE``.
+        """
+        del request
+        self._complete_file_selector(selector_id, SelectedFilesStatus.UNAVAILABLE)
+
+    # Optional to implement
+    def _cancel_active_file_selectors(self) -> None:
+        """Withdraw the picker that :meth:`flush_file_selectors` forgot."""
+        pass
 
-        Returns:
-            The result when it is known immediately, otherwise ``None``.
+    # Optional to implement
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        """Queue ``event`` for :meth:`InputSource.get_user_input_events`.
+
+        Only window code calls this. It may run on any thread.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement _put_user_input_event to "
+            "report file selections."
+        )
+
+    @final
+    def _file_selector_opened(self, selector_id: int) -> None:
+        """Stop the deadline because the picker for ``selector_id`` is shown."""
+        with _FILE_SELECTOR_LOCK:
+            active = self._active_file_selector
+            if active is not None and active[0] == selector_id:
+                self._file_selector_deadline = None
+
+    @final
+    def _complete_file_selector(
+        self,
+        selector_id: int,
+        status: SelectedFilesStatus,
+        files: tuple[SelectedFile, ...] = (),
+    ) -> None:
+        """Report the result for ``selector_id``; a stale id is dropped."""
+        with _FILE_SELECTOR_LOCK:
+            active = self._active_file_selector
+            if active is None or active[0] != selector_id:
+                return
+            self._active_file_selector = None
+            self._file_selector_deadline = None
+        self._put_user_input_event(
+            SelectedFilesUserInputEvent(
+                timestamp=uint64(0),
+                request_id=active[1].request_id,
+                status=status,
+                files=files,
+            )
+        )
+
+    @final
+    def _expire_file_selectors(self) -> None:
+        """Complete a picker not shown by its deadline as ``UNAVAILABLE``.
+
+        Windows with a picker call this each time input is read.
         """
-        return SelectedFilesUserInputEvent(
-            timestamp=uint64(0),
-            request_id=request.request_id,
-            status=SelectedFilesStatus.UNAVAILABLE,
+        with _FILE_SELECTOR_LOCK:
+            active = self._active_file_selector
+            deadline = self._file_selector_deadline
+            if (
+                active is None
+                or deadline is None
+                or self._file_selector_clock() < deadline
+            ):
+                return
+        _LOGGER.warning(
+            "File selector %r was not shown within %g seconds.",
+            active[1].request_id,
+            FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
         )
+        self._complete_file_selector(active[0], SelectedFilesStatus.UNAVAILABLE)
+
+
+# ponytail: one lock for every window keeps subclasses constructor-free; it only
+# guards a few assignments. Upgrade path: a per-window lock set in ``__init__``.
+_FILE_SELECTOR_LOCK = threading.Lock()
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index ad1b1c3d5..36b2d32b9 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -598,44 +598,42 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         self.get_or_create_ui_loop_requests().new_window_size = new_window_size
 
     @final
-    def file_selector(
+    def request_file_selector(
         self,
         request_id: str,
         initial_path: str | None = None,
         *,
-        open: bool = False,
         accept: Sequence[str] = (),
         max_file_bytes: int | None = None,
         multiple: bool = False,
-    ) -> SelectedFilesUserInputEvent | None:
-        """Request files from the client and return this tick's matching result.
-
-        Call every UI tick from each place in the UI that can open a picker.
-        Pass ``open=True`` only on the tick that the user asks to open it, such
-        as when an ImGui button returns ``True``. Use a different stable
-        ``request_id`` for each such place. Sharing an id between places is
-        not supported: a pick made from one place would also be reported to
-        the other.
-        One picker is open at a time: another ``open=True`` for the open
-        ``request_id`` is ignored, and one for any other id completes as
-        ``UNAVAILABLE``.
+    ) -> None:
+        """Ask the client to show a file selector.
+
+        The result arrives on a later tick as one
+        :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`
+        in :attr:`user_events`, carrying ``request_id``. Read its ``status``;
+        use ``files`` only when the pick succeeded. One selector is open at a
+        time: a request made while one is open is ignored and gets no result.
 
         Example:
 
         .. code-block:: python
 
-            pick = self.file_selector("open-image", open=imgui.button("Open"))
-            if pick is not None and pick.status is SelectedFilesStatus.OK:
-                image_bytes = pick.files[0].data
+            if imgui.button("Open image"):
+                self.request_file_selector("open-image", accept=(".png",))
+            for event in self.user_events.get_events():
+                if (
+                    isinstance(event, SelectedFilesUserInputEvent)
+                    and event.request_id == "open-image"
+                    and event.status is SelectedFilesStatus.OK
+                ):
+                    image_bytes = event.files[0].data
 
         Args:
-            request_id: Stable id for this place in the UI. Echoed on the
-                matching event. Supplied by the app, like an ImGui widget id,
-                because it must stay the same across the ticks between
-                opening a picker and receiving its result.
+            request_id: Names the place in the UI that asked, so its result
+                can be told apart from another place's. Echoed on the result.
             initial_path: Directory hint for the selector; ``None`` uses the
                 current user's home directory.
-            open: Whether to start a selector this tick.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_file_bytes: Maximum size of each file in bytes, or ``None`` for
                 the ceiling. Larger values clamp to
@@ -644,14 +642,10 @@ def file_selector(
                 whole set is also capped by
                 :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BATCH_BYTES`.
 
-        Returns:
-            This tick's selected-files event for ``request_id``, or ``None``.
-            Read ``status``; use ``files`` only when the pick succeeded.
-
         Raises:
             TypeError: ``request_id`` or ``initial_path`` is not a string, or
-                ``open`` / ``accept`` / ``max_file_bytes`` / ``multiple`` has
-                the wrong type.
+                ``accept`` / ``max_file_bytes`` / ``multiple`` has the wrong
+                type.
             ValueError: ``request_id`` or ``initial_path`` is empty, or
                 ``accept`` / ``max_file_bytes`` is invalid.
         """
@@ -659,43 +653,31 @@ def file_selector(
             raise TypeError("request_id must be a string.")
         if not request_id:
             raise ValueError("request_id must be a non-empty string.")
-        if not isinstance(open, bool):
-            raise TypeError("open must be a bool.")
-        if open:
-            if initial_path is None:
-                resolved_initial_path = str(Path.home())
-            else:
-                if not isinstance(initial_path, str):
-                    raise TypeError("initial_path must be a string.")
-                if not initial_path:
-                    raise ValueError("initial_path must be a non-empty string.")
-                resolved_initial_path = initial_path
-            suffixes = normalize_selected_file_accept(accept)
-            if max_file_bytes is not None:
-                if isinstance(max_file_bytes, bool) or not isinstance(
-                    max_file_bytes, int
-                ):
-                    raise TypeError("max_file_bytes must be an integer.")
-                if max_file_bytes <= 0:
-                    raise ValueError("max_file_bytes must be > 0.")
-            if not isinstance(multiple, bool):
-                raise TypeError("multiple must be a bool.")
-            self.get_or_create_ui_loop_requests().file_selections.append(
-                FileSelectionRequest(
-                    request_id=request_id,
-                    initial_path=resolved_initial_path,
-                    accept=suffixes,
-                    max_bytes=max_file_bytes,
-                    multiple=multiple,
-                )
+        if initial_path is None:
+            resolved_initial_path = str(Path.home())
+        else:
+            if not isinstance(initial_path, str):
+                raise TypeError("initial_path must be a string.")
+            if not initial_path:
+                raise ValueError("initial_path must be a non-empty string.")
+            resolved_initial_path = initial_path
+        suffixes = normalize_selected_file_accept(accept)
+        if max_file_bytes is not None:
+            if isinstance(max_file_bytes, bool) or not isinstance(max_file_bytes, int):
+                raise TypeError("max_file_bytes must be an integer.")
+            if max_file_bytes <= 0:
+                raise ValueError("max_file_bytes must be > 0.")
+        if not isinstance(multiple, bool):
+            raise TypeError("multiple must be a bool.")
+        self.get_or_create_ui_loop_requests().file_selections.append(
+            FileSelectionRequest(
+                request_id=request_id,
+                initial_path=resolved_initial_path,
+                accept=suffixes,
+                max_bytes=max_file_bytes,
+                multiple=multiple,
             )
-        for event in self.user_events.get_events():
-            if (
-                isinstance(event, SelectedFilesUserInputEvent)
-                and event.request_id == request_id
-            ):
-                return event
-        return None
+        )
 
     def get_or_create_ui_loop_requests(self) -> UILoopRequests:
         if self._ui_loop_requests is None:
diff --git a/flashdreams/flashdreams/runtime_v2/README.md b/flashdreams/flashdreams/runtime_v2/README.md
index 9fdcedda1..f0a798a34 100644
--- a/flashdreams/flashdreams/runtime_v2/README.md
+++ b/flashdreams/flashdreams/runtime_v2/README.md
@@ -374,6 +374,20 @@ chooses its UI independently of the client window. Browser keyboard, mouse,
 focus, and file-selector events arrive on the server's own thread, so it queues
 them and hands them over in batches when the session asks.
 
+File selection rules live in `IClientWindow` itself: one picker at a time
+(another request while one is open is ignored), `UNAVAILABLE` if a picker is
+not shown within 30 seconds, and exactly one result per request. A window
+only shows the picker. It implements `_put_user_input_event` to queue an event
+for `get_user_input_events`; that alone is enough for a window without a
+picker, which then answers every request with `UNAVAILABLE`. A window with a
+picker also implements `_request_file_selector(selector_id, request)` without
+blocking, calls `_file_selector_opened(selector_id)` once the picker is shown,
+then `_complete_file_selector(selector_id, status, files)` from any thread, and
+calls `_expire_file_selectors()` each time its input is read. A result for a
+picker that was forgotten when its session ended is dropped. A window that
+wraps another forwards `request_file_selector` and `flush_file_selectors` to
+it instead.
+
 A UI loop may call `request_new_session(session_desc)` during its step with a
 fully resolved replacement description. `run_session` stops and cleans the
 current session, leaves the interactive window open, and returns that
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index 3e2c72ac6..eec786e28 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.mp4_output_sink import Mp4OutputSink
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
@@ -13,7 +14,7 @@
 
 
 class Mp4ClientWindow(IClientWindow):
-    """Write UI frames to an MP4 file and report no input.
+    """Write UI frames to an MP4 file and report no input except file results.
 
     The session must finish on its own because this window never sends a close
     event. Use ``BackpressureMode.BLOCK`` with
@@ -27,6 +28,7 @@ def __init__(self, path: str | Path) -> None:
         """
         self._path = Path(path)
         self._video_sink = Mp4OutputSink(path)
+        self._input_events: list[UserInputEvent] = []
 
     @property
     def path(self) -> Path:
@@ -34,8 +36,12 @@ def path(self) -> Path:
         return self._path
 
     def get_user_input_events(self) -> UserInputEvents:
-        """Return an empty input batch."""
-        return UserInputEvents([])
+        """Return the file-selection results queued since the last call."""
+        events, self._input_events = self._input_events, []
+        return UserInputEvents(events)
+
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        self._input_events.append(event)
 
     def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """Change the MP4 presentation dimensions without replacing the session.
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index 5755000fe..e083d4bbc 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -34,13 +34,11 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
-    FileSelectorOpenedUserInputEvent,
     FullscreenEnabledOptimalWindowSizeUserInputEvent,
     GamepadUserInputEvent,
     KeyboardInputState,
     KeyboardUserInputEvent,
     MouseUserInputEvent,
-    SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 from flashdreams.runtime_v2.video_encoder import result_to_rgb24_tensor
@@ -279,17 +277,24 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
             )
         self._window_size = presenter.resize(*new_window_size)
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
+    def _request_file_selector(
+        self, selector_id: int, request: FileSelectionRequest
+    ) -> None:
         """Open the Tk file dialog on a worker thread so the window keeps presenting."""
+        # ponytail: Tk cannot close this dialog from another thread, so one
+        # left open after its session ended can sit beside a newer one; its
+        # result is dropped. Upgrade path: run the dialog in a child process.
         threading.Thread(
             target=self._complete_file_selection,
-            args=(request,),
+            args=(selector_id, request),
             name="flashdreams-file-picker",
             daemon=True,
         ).start()
 
-    def _complete_file_selection(self, request: FileSelectionRequest) -> None:
-        """Run the file dialog, then queue ``opened`` and one result event."""
+    def _complete_file_selection(
+        self, selector_id: int, request: FileSelectionRequest
+    ) -> None:
+        """Run the file dialog, then report it opened and its result."""
         files: tuple[SelectedFile, ...] = ()
         status = SelectedFilesStatus.UNAVAILABLE
         try:
@@ -297,11 +302,7 @@ def _complete_file_selection(self, request: FileSelectionRequest) -> None:
                 initial_dir=request.initial_path or str(Path.home()),
                 accept=request.accept,
                 multiple=request.multiple,
-                on_presented=lambda: self._put_from_worker(
-                    FileSelectorOpenedUserInputEvent(
-                        timestamp=uint64(0), request_id=request.request_id
-                    )
-                ),
+                on_presented=lambda: self._file_selector_opened(selector_id),
             )
         except Exception:
             _LOGGER.exception(
@@ -316,14 +317,7 @@ def _complete_file_selection(self, request: FileSelectionRequest) -> None:
                 )
             else:
                 status = SelectedFilesStatus.CANCELLED
-        self._put_from_worker(
-            SelectedFilesUserInputEvent(
-                timestamp=uint64(0),
-                request_id=request.request_id,
-                status=status,
-                files=files,
-            )
-        )
+        self._complete_file_selector(selector_id, status, files)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Open a session in the GLFW window on the runtime's UI thread.
@@ -387,6 +381,7 @@ def open(self, session_desc: SessionDesc) -> None:
 
     def get_user_input_events(self) -> UserInputEvents:
         """Pump GLFW and return native input events not yet read."""
+        self._expire_file_selectors()
         presenter = self._presenter
         if presenter is not None:
             pending_before_poll = tuple(self._pending_printable_keys)
@@ -553,7 +548,7 @@ def _on_window_closed(self) -> None:
         self._close_event_enqueued = True
         self._put_input(CloseUserInputEvent(timestamp=uint64(0)))
 
-    def _put_from_worker(self, event: UserInputEvent) -> None:
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
         """Queue one event from a picker thread, bypassing the poll-time buffer."""
         started_ns = self._session_started_ns
         elapsed_ns = 0 if started_ns is None else max(0, self._clock_ns() - started_ns)
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index 76ff107fa..f5163217e 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -4,17 +4,25 @@
 """Client window that discards output and reports no input."""
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 
 class NullClientWindow(IClientWindow):
-    """Discard output and report no input."""
+    """Discard output and report no input except file-selection results."""
+
+    def __init__(self) -> None:
+        self._input_events: list[UserInputEvent] = []
 
     def get_user_input_events(self) -> UserInputEvents:
-        """Return an empty input batch."""
-        return UserInputEvents([])
+        """Return the file-selection results queued since the last call."""
+        events, self._input_events = self._input_events, []
+        return UserInputEvents(events)
+
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        self._input_events.append(event)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Accept a session without opening an output."""
diff --git a/flashdreams/flashdreams/runtime_v2/selected_file.py b/flashdreams/flashdreams/runtime_v2/selected_file.py
index c57a90659..65d9f339c 100644
--- a/flashdreams/flashdreams/runtime_v2/selected_file.py
+++ b/flashdreams/flashdreams/runtime_v2/selected_file.py
@@ -104,8 +104,8 @@ class SelectedFilesStatus(Enum):
     """A chosen file did not match ``accept``. Checked before size."""
 
     UNAVAILABLE = "unavailable"
-    """No pick was made: another picker was open, the client has no picker or
-    left, the picker was not shown in time, or a chosen file was unreadable."""
+    """No pick was made: the client has no picker or left, the picker was not
+    shown in time, or a chosen file was unreadable."""
 
 
 def selected_file_policy_status(
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 4948c065d..a85a07f4e 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -43,7 +43,6 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
-    FileSelectorOpenedUserInputEvent,
     FocusUserInputEvent,
     GamepadUserInputEvent,
     GameWheelUserInputEvent,
@@ -52,7 +51,6 @@
     MouseUserInputEvent,
     QueryStringUserInputEvent,
     ResetUserInputEvent,
-    SelectedFilesUserInputEvent,
     TouchUserInputEvent,
     UserInputEvent,
     XRControllerUserInputEvent,
@@ -374,6 +372,13 @@ def __init__(
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._pending_file_requests: dict[str, _PendingFileSelection] = {}
+        self._file_selector_callbacks: (
+            tuple[
+                Callable[[str], None],
+                Callable[[str, SelectedFilesStatus, tuple[SelectedFile, ...]], None],
+            ]
+            | None
+        ) = None
         self._file_selector_lock = threading.Lock()
         self._thread = threading.Thread(
             target=self._run_server,
@@ -465,13 +470,16 @@ def _send_cursor_options(self) -> None:
 
         self._sent_cursor_options = cursor_options
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
+    def request_file_selector(
+        self, request_id: str, request: FileSelectionRequest
+    ) -> None:
         """Ask the connected browser to open a file selector.
 
         The browser cannot use a host path, so ``initial_path`` is ignored.
         Without a connected viewer the request completes as ``UNAVAILABLE``.
 
         Args:
+            request_id: Id the browser echoes back with this selector's result.
             request: File selector to show.
         """
         policy = _PendingFileSelection(
@@ -482,7 +490,12 @@ def request_selected_files(self, request: FileSelectionRequest) -> None:
         loop = self._loop
         if loop is None:
             raise RuntimeError("WebRTC server is not running.")
-        loop.call_soon_threadsafe(self._arm_file_selector, request.request_id, policy)
+        loop.call_soon_threadsafe(self._arm_file_selector, request_id, policy)
+
+    def cancel_file_selectors(self) -> None:
+        """Forget every armed selector; a later upload for one is refused."""
+        with self._file_selector_lock:
+            self._pending_file_requests.clear()
 
     def _arm_file_selector(
         self, request_id: str, policy: _PendingFileSelection
@@ -491,9 +504,7 @@ def _arm_file_selector(
         channel = self._control_channel
         if channel is None or channel.readyState != "open":
             self._emit_selected_files(
-                self._timestamp_us() or np.uint64(0),
-                request_id,
-                status=SelectedFilesStatus.UNAVAILABLE,
+                request_id, status=SelectedFilesStatus.UNAVAILABLE
             )
             return
         with self._file_selector_lock:
@@ -522,10 +533,9 @@ def _complete_abandoned_file_selectors(self) -> None:
         with self._file_selector_lock:
             abandoned = tuple(self._pending_file_requests)
             self._pending_file_requests.clear()
-        timestamp_us = self._timestamp_us() or np.uint64(0)
         for request_id in abandoned:
             self._emit_selected_files(
-                timestamp_us, request_id, status=SelectedFilesStatus.UNAVAILABLE
+                request_id, status=SelectedFilesStatus.UNAVAILABLE
             )
 
     def event_timestamp_us(self) -> np.uint64:
@@ -648,6 +658,22 @@ def register_input_callback(
             raise RuntimeError("An input callback is already registered.")
         self._input_callback = callback
 
+    def register_file_selector_callbacks(
+        self,
+        *,
+        opened: Callable[[str], None],
+        completed: Callable[[str, SelectedFilesStatus, tuple[SelectedFile, ...]], None],
+    ) -> None:
+        """Register how armed file selectors report back, by request id.
+
+        Both run on the server thread.
+
+        Args:
+            opened: Called when the browser shows the selector.
+            completed: Called once with the selector's status and files.
+        """
+        self._file_selector_callbacks = (opened, completed)
+
     def write(self, result: StepResult) -> None:
         """Materialize and admit one generated result to the sender mailbox.
 
@@ -863,8 +889,7 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
         """Turn a browser file upload into a selected-files input event."""
         if self._closed:
             raise web.HTTPServiceUnavailable(reason="WebRTC server is closed.")
-        timestamp_us = self._timestamp_us()
-        if timestamp_us is None:
+        if self._timestamp_us() is None:
             raise web.HTTPConflict(reason="WebRTC server is not open.")
         request_id = request.query.get("request_id")
         if not isinstance(request_id, str) or not request_id:
@@ -882,9 +907,7 @@ def emit(
             files: tuple[SelectedFile, ...] = (),
         ) -> None:
             nonlocal emitted
-            self._emit_selected_files(
-                timestamp_us, request_id, status=status, files=files
-            )
+            self._emit_selected_files(request_id, status=status, files=files)
             emitted = True
 
         try:
@@ -1292,9 +1315,8 @@ def _buffer_browser_message(
             with self._file_selector_lock:
                 if request_id not in self._pending_file_requests:
                     return
-            event = FileSelectorOpenedUserInputEvent(
-                timestamp=timestamp_us, request_id=request_id
-            )
+            self._file_selector_callbacks_or_raise()[0](request_id)
+            return
         elif event_type == "file_selector_result":
             request_id = payload.get("id")
             if not isinstance(request_id, str) or not request_id:
@@ -1310,7 +1332,7 @@ def _buffer_browser_message(
                 )
             if self._take_pending_file_request(request_id) is None:
                 return
-            self._emit_selected_files(timestamp_us, request_id, status=status)
+            self._emit_selected_files(request_id, status=status)
             return
         else:
             raise ValueError("Unsupported browser event type.")
@@ -1325,21 +1347,24 @@ def _append_event(self, event: UserInputEvent) -> None:
 
     def _emit_selected_files(
         self,
-        timestamp_us: np.uint64,
         request_id: str,
         *,
         status: SelectedFilesStatus,
         files: tuple[SelectedFile, ...] = (),
     ) -> None:
-        """Append one selected-files event."""
-        self._append_event(
-            SelectedFilesUserInputEvent(
-                timestamp=timestamp_us,
-                request_id=request_id,
-                status=status,
-                files=files,
-            )
-        )
+        """Report the result of one armed file selector to the window."""
+        self._file_selector_callbacks_or_raise()[1](request_id, status, files)
+
+    def _file_selector_callbacks_or_raise(
+        self,
+    ) -> tuple[
+        Callable[[str], None],
+        Callable[[str, SelectedFilesStatus, tuple[SelectedFile, ...]], None],
+    ]:
+        callbacks = self._file_selector_callbacks
+        if callbacks is None:
+            raise RuntimeError("WebRTC file selector callbacks are not registered.")
+        return callbacks
 
     async def _release_peer_connection(
         self,
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 44d141262..6c481929c 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -11,8 +11,6 @@
 from dataclasses import dataclass
 from pathlib import Path
 
-from numpy import uint64
-
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.loop import (
     IModelLoop,
@@ -22,22 +20,11 @@
 )
 from flashdreams.api_v2.profiler import IProfiler
 from flashdreams.api_v2.session import ISession
-from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.coordination import StepAgreement
 from flashdreams.runtime_v2.event_buffer import EventBuffer
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
-from flashdreams.runtime_v2.selected_file import (
-    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
-    FileSelectionRequest,
-    SelectedFilesStatus,
-)
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
-from flashdreams.runtime_v2.user_input_event import (
-    FileSelectorOpenedUserInputEvent,
-    SelectedFilesUserInputEvent,
-)
-from flashdreams.runtime_v2.user_input_events import UserInputEvents
 
 _LOGGER = logging.getLogger(__name__)
 _MODEL_THREAD_NAME = "flashdreams-model-generation-thread"
@@ -59,88 +46,6 @@ class _ChunkTraceLog:
     previous_propagate: bool
 
 
-class _FileSelections:
-    """Allow one client file picker at a time for a session, on the UI thread.
-
-    A request made while another picker is active completes as
-    ``UNAVAILABLE``. The active request has a deadline until its window reports
-    the picker opened; after that the user may take as long as they want.
-    Results for any other id are dropped, so each request gets one result.
-    """
-
-    # ponytail: a picker that opens after its deadline, or one left open across a
-    # session replacement, can sit beside the next one. Upgrade path: have
-    # windows report when a dialog closes and wait for that before the next.
-
-    def __init__(
-        self,
-        window: IClientWindow,
-        *,
-        timeout_seconds: float = FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
-        clock: Callable[[], float] = time.monotonic,
-    ) -> None:
-        self._window = window
-        self._timeout_seconds = timeout_seconds
-        self._clock = clock
-        self._active: FileSelectionRequest | None = None
-        self._deadline: float | None = None
-        self._ready: list[UserInputEvent] = []
-
-    def request(self, request: FileSelectionRequest) -> None:
-        """Start ``request``; a result known right away is held for :meth:`filter`."""
-        active = self._active
-        if active is not None:
-            if active.request_id != request.request_id:
-                self._ready.append(self._unavailable(request))
-            return
-        self._active = request
-        self._deadline = self._clock() + self._timeout_seconds
-        try:
-            result = self._window.request_selected_files(request)
-        except Exception:
-            _LOGGER.exception("File selector %r failed to start.", request.request_id)
-            result = self._unavailable(request)
-        if result is not None:
-            self._active = None
-            self._ready.append(result)
-
-    def filter(self, events: list[UserInputEvent]) -> list[UserInputEvent]:
-        """Apply window file events and the deadline; return events for the loops."""
-        kept, self._ready = self._ready, []
-        for event in events:
-            active = self._active
-            if isinstance(event, FileSelectorOpenedUserInputEvent):
-                if active is not None and active.request_id == event.request_id:
-                    self._deadline = None
-            elif isinstance(event, SelectedFilesUserInputEvent):
-                if active is not None and active.request_id == event.request_id:
-                    kept.append(event)
-                    self._active = None
-            else:
-                kept.append(event)
-        if (
-            self._active is not None
-            and self._deadline is not None
-            and self._clock() >= self._deadline
-        ):
-            _LOGGER.warning(
-                "File selector %r was not shown within %g seconds.",
-                self._active.request_id,
-                self._timeout_seconds,
-            )
-            kept.append(self._unavailable(self._active))
-            self._active = None
-        return kept
-
-    @staticmethod
-    def _unavailable(request: FileSelectionRequest) -> SelectedFilesUserInputEvent:
-        return SelectedFilesUserInputEvent(
-            timestamp=uint64(0),
-            request_id=request.request_id,
-            status=SelectedFilesStatus.UNAVAILABLE,
-        )
-
-
 def _log_secondary_failure(message: str, error: BaseException) -> None:
     """Log a cleanup failure that cannot replace an earlier exception."""
     _LOGGER.error(message, exc_info=error)
@@ -221,7 +126,6 @@ def run_session(
     agreement: StepAgreement | None = None
 
     event_buffer = EventBuffer()
-    file_selections = None if window is None else _FileSelections(window)
     model_thread_handle: threading.Thread | None = None
     ui_loop: IUILoop[object] | None = None
     model_loop: IModelLoop[object] | None = None
@@ -267,11 +171,9 @@ def expire_if_due() -> bool:
             return False
 
         def collect_input() -> None:
-            if window is None or file_selections is None:
+            if window is None:
                 return
-            events = UserInputEvents(
-                file_selections.filter(window.get_user_input_events().get_events())
-            )
+            events = window.get_user_input_events()
             received_ns = time.monotonic_ns()
             # Before the model thread can read the batch, so no step consumes
             # input the profiler has not seen arrive.
@@ -282,7 +184,7 @@ def collect_input() -> None:
         def run_ui_once(*, step_requested: bool = True) -> None:
             """Process UI lifecycle control and run a requested UI step."""
             nonlocal next_session_desc
-            if ui_loop is None or window is None or file_selections is None:
+            if ui_loop is None or window is None:
                 return
             events, generation = event_buffer.read(_UI_READER_ID)
             result: list[StepResult] | None = None
@@ -296,8 +198,6 @@ def run_ui_once(*, step_requested: bool = True) -> None:
                 request = ui_loop.flush_ui_loop_requests()
                 if request is not None:
                     _apply_window_requests(window, request)
-                    for item in request.file_selections:
-                        file_selections.request(item)
                     if request.new_session is not None:
                         next_session_desc = request.new_session
                         stop.set()
@@ -492,6 +392,8 @@ def should_end_ui() -> bool:
             cleanup(sink.close)
         # Both loops have stopped, so nothing will close an input wait still open.
         cleanup(profiler.reset_counts)
+        if window is not None:
+            cleanup(window.flush_file_selectors)
         if next_session_desc is None and window is not None:
             cleanup(window.close)
         cleanup(session.close)
@@ -546,6 +448,8 @@ def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> No
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
+    for file_selection in request.file_selections:
+        window.request_file_selector(file_selection)
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/flashdreams/runtime_v2/user_input_event.py b/flashdreams/flashdreams/runtime_v2/user_input_event.py
index 6e8e2bf99..7c3e2bacf 100644
--- a/flashdreams/flashdreams/runtime_v2/user_input_event.py
+++ b/flashdreams/flashdreams/runtime_v2/user_input_event.py
@@ -250,7 +250,8 @@ def get_type_name(cls) -> str:
 class SelectedFilesUserInputEvent(UserInputEvent):
     """Result of one file-selector request.
 
-    Applications receive it from :meth:`IUILoop.file_selector`.
+    The answer to :meth:`IUILoop.request_file_selector`, read from
+    ``user_events`` like any other input.
     ``OK`` is the only status with files; every other status has empty ``files``.
     """
 
@@ -279,23 +280,6 @@ def __post_init__(self) -> None:
             raise ValueError("failed selected-files events must not include files.")
 
 
-@dataclass(frozen=True, slots=True, eq=False)
-class FileSelectorOpenedUserInputEvent(UserInputEvent):
-    """A client window showed the picker for one file-selector request.
-
-    The runtime consumes it to stop that request's presentation deadline.
-    Applications never receive it.
-    """
-
-    @classmethod
-    def get_type_name(cls) -> str:
-        """Return the event type name."""
-        return "file_selector_opened"
-
-    request_id: str
-    """``request_id`` of the request whose picker is now shown."""
-
-
 @dataclass(frozen=True, slots=True, eq=False)
 class UnknownUserInputEvent(UserInputEvent):
     """User input event for an unknown input modality."""
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 380829fb7..9143ed8b7 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -72,6 +72,12 @@ def handle_input(event: UserInputEvent) -> None:
                 self._input_events.append(event)
 
         self.server.register_input_callback(handle_input)
+        self.server.register_file_selector_callbacks(
+            opened=lambda request_id: self._file_selector_opened(int(request_id)),
+            completed=lambda request_id, status, files: self._complete_file_selector(
+                int(request_id), status, files
+            ),
+        )
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Show or hide the cursor in the browser window."""
@@ -101,9 +107,21 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         self.server.request_new_window_size(new_window_size)
 
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
+    def _request_file_selector(
+        self, selector_id: int, request: FileSelectionRequest
+    ) -> None:
         """Ask the connected browser to open a file selector."""
-        self.server.request_selected_files(request)
+        self.server.request_file_selector(str(selector_id), request)
+
+    def _cancel_active_file_selectors(self) -> None:
+        """Refuse a later upload for the selector that was forgotten."""
+        self.server.cancel_file_selectors()
+
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        """Queue a file-selection event on the server's clock, like browser input."""
+        event = replace(event, timestamp=self.server.event_timestamp_us())
+        with self._input_lock:
+            self._input_events.append(event)
 
     def open(self, session_desc: SessionDesc) -> None:
         """Implement ``OutputSink.open`` by configuring WebRTC output.
@@ -123,6 +141,7 @@ def get_user_input_events(self) -> UserInputEvents:
         Returns:
             Buffered browser events in timestamp order, each returned once.
         """
+        self._expire_file_selectors()
         with self._input_lock:
             events = list(self._input_events)
             self._input_events.clear()
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 7655bb980..82f074ee0 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -30,7 +30,6 @@
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
-    FileSelectorOpenedUserInputEvent,
     FullscreenEnabledOptimalWindowSizeUserInputEvent,
     GamepadUserInputEvent,
     KeyboardInputState,
@@ -720,7 +719,7 @@ def test_native_window_reports_a_selected_file(
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    window.request_file_selector(_file_request("open-1", str(tmp_path)))
     events = _wait_for_input_events(window)
     window.close()
 
@@ -746,7 +745,7 @@ def test_native_window_reports_cancelled_file_selection(
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    window.request_file_selector(_file_request("open-1", str(tmp_path)))
     events = _wait_for_input_events(window)
     window.close()
 
@@ -777,7 +776,7 @@ def fail_picker(
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
+    window.request_file_selector(_file_request("open-1", str(tmp_path)))
     events = _wait_for_input_events(window)
     window.close()
 
@@ -822,9 +821,12 @@ def test_selected_files_from_paths_skips_unreadable_and_oversize(
     assert status is SelectedFilesStatus.DISALLOWED_TYPE
 
 
-def test_native_window_reports_opened_before_the_result(
+def test_native_window_shown_picker_has_no_deadline(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
+    shown = threading.Event()
+    release = threading.Event()
+
     def picker(
         *,
         initial_dir: str,
@@ -835,29 +837,28 @@ def picker(
         del initial_dir, accept, multiple
         assert on_presented is not None
         on_presented()
+        shown.set()
+        release.wait(5)
         return ()
 
     monkeypatch.setattr(native_window_module, "_ask_open_filename", picker)
+    now = [0.0]
     presenter = _Presenter()
     window = NativeWindowClientWindow(presenter_factory=_presenter_factory(presenter))
+    window._file_selector_clock = lambda: now[0]
     window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path)))
-    events: list[object] = []
-    for _ in range(100):
-        events.extend(window.get_user_input_events().get_events())
-        if len(events) >= 2:
-            break
-        time.sleep(0.01)
+    window.request_file_selector(_file_request("open-1", str(tmp_path)))
+    assert shown.wait(5)
+    now[0] = 1_000.0
+    assert window.get_user_input_events().get_events() == []
+    release.set()
+    events = _wait_for_input_events(window)
     window.close()
 
-    assert [type(event) for event in events] == [
-        FileSelectorOpenedUserInputEvent,
-        SelectedFilesUserInputEvent,
-    ]
-    assert all(
-        cast(SelectedFilesUserInputEvent, event).request_id == "open-1"
-        for event in events
-    )
+    assert len(events) == 1
+    event = events[0]
+    assert isinstance(event, SelectedFilesUserInputEvent)
+    assert event.status is SelectedFilesStatus.CANCELLED
 
 
 def test_native_window_reports_multiple_selected_files(
@@ -880,7 +881,7 @@ def test_native_window_reports_multiple_selected_files(
         presenter_factory=_presenter_factory(presenter),
     )
     window.open(_session_desc())
-    window.request_selected_files(_file_request("open-1", str(tmp_path), multiple=True))
+    window.request_file_selector(_file_request("open-1", str(tmp_path), multiple=True))
     events = _wait_for_input_events(window)
     window.close()
 
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 730e0207b..3c6237cd0 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -10,12 +10,13 @@
 import pytest
 from numpy import uint64
 
+from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.loop import IUILoop
-from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.mp4_client_window import Mp4ClientWindow
 from flashdreams.runtime_v2.null_client_window import NullClientWindow
 from flashdreams.runtime_v2.presentation_manager import PresentationManager
 from flashdreams.runtime_v2.selected_file import (
+    FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
     MAX_SELECTED_FILE_BATCH_BYTES,
     MAX_SELECTED_FILE_BYTES,
     FileSelectionRequest,
@@ -28,11 +29,8 @@
     selected_files_policy_status,
 )
 from flashdreams.runtime_v2.session_desc import SessionDesc
-from flashdreams.runtime_v2.session_runner import _FileSelections
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    CloseUserInputEvent,
-    FileSelectorOpenedUserInputEvent,
     SelectedFilesUserInputEvent,
 )
 from flashdreams.runtime_v2.user_input_events import UserInputEvents
@@ -66,10 +64,9 @@ def _ui_loop() -> _UILoop:
 
 def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
     loop = _ui_loop()
-    loop.file_selector(
+    loop.request_file_selector(
         "open-1",
         "/tmp",
-        open=True,
         accept=(".png", ".JPG"),
         max_file_bytes=MAX_SELECTED_FILE_BYTES * 2,
         multiple=True,
@@ -88,7 +85,7 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
 
 def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
     loop = _ui_loop()
-    loop.file_selector("open-1", open=True)
+    loop.request_file_selector("open-1")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
@@ -97,8 +94,8 @@ def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
 
 def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
     loop = _ui_loop()
-    loop.file_selector("open-1", "/tmp", open=True)
-    loop.file_selector("open-2", "/var", open=True)
+    loop.request_file_selector("open-1", "/tmp")
+    loop.request_file_selector("open-2", "/var")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
@@ -128,98 +125,102 @@ def test_ui_loop_keeps_file_results_until_a_step_runs() -> None:
 
 class _PickerWindow(NullClientWindow):
     def __init__(self) -> None:
-        self.started: list[str] = []
-
-    def request_selected_files(self, request: FileSelectionRequest) -> None:
-        self.started.append(request.request_id)
-
-
-class _Clock:
-    def __init__(self) -> None:
+        super().__init__()
         self.now = 0.0
+        self._file_selector_clock = lambda: self.now
+        self.started: list[tuple[int, str]] = []
+        self.cancelled = 0
+
+    def _request_file_selector(
+        self, selector_id: int, request: FileSelectionRequest
+    ) -> None:
+        self.started.append((selector_id, request.request_id))
 
-    def __call__(self) -> float:
-        return self.now
+    def _cancel_active_file_selectors(self) -> None:
+        self.cancelled += 1
 
 
 def _request(request_id: str) -> FileSelectionRequest:
     return FileSelectionRequest(request_id=request_id, initial_path="/tmp")
 
 
-def _opened(request_id: str) -> FileSelectorOpenedUserInputEvent:
-    return FileSelectorOpenedUserInputEvent(timestamp=uint64(0), request_id=request_id)
-
-
-def _result(request_id: str) -> SelectedFilesUserInputEvent:
-    return SelectedFilesUserInputEvent(
-        timestamp=uint64(0),
-        request_id=request_id,
-        status=SelectedFilesStatus.CANCELLED,
-    )
-
-
-def _statuses(events: list[UserInputEvent]) -> list[tuple[str, SelectedFilesStatus]]:
+def _statuses(window: IClientWindow) -> list[tuple[str, SelectedFilesStatus]]:
     return [
         (event.request_id, event.status)
-        for event in events
+        for event in window.get_user_input_events().get_events()
         if isinstance(event, SelectedFilesUserInputEvent)
     ]
 
 
-def test_session_shows_one_picker_at_a_time() -> None:
+def test_window_shows_one_picker_at_a_time() -> None:
     window = _PickerWindow()
-    selections = _FileSelections(window, timeout_seconds=1.0, clock=_Clock())
-    selections.request(_request("open-1"))
-    selections.request(_request("open-1"))
-    selections.request(_request("open-2"))
-    assert window.started == ["open-1"]
-    busy = selections.filter([_result("open-2")])
-    assert _statuses(busy) == [("open-2", SelectedFilesStatus.UNAVAILABLE)]
+    window.request_file_selector(_request("open-1"))
+    window.request_file_selector(_request("open-1"))
+    window.request_file_selector(_request("open-2"))
+    assert [request_id for _, request_id in window.started] == ["open-1"]
+    assert _statuses(window) == []
 
-    kept = selections.filter([_result("open-1")])
-    assert _statuses(kept) == [("open-1", SelectedFilesStatus.CANCELLED)]
-    selections.request(_request("open-2"))
-    assert window.started == ["open-1", "open-2"]
+    selector_id = window.started[0][0]
+    window._complete_file_selector(selector_id, SelectedFilesStatus.CANCELLED)
+    window._complete_file_selector(selector_id, SelectedFilesStatus.CANCELLED)
+    assert _statuses(window) == [("open-1", SelectedFilesStatus.CANCELLED)]
+    window.request_file_selector(_request("open-2"))
+    assert [request_id for _, request_id in window.started] == ["open-1", "open-2"]
 
 
-def test_session_times_out_unopened_picker_and_drops_its_late_result() -> None:
+def test_window_times_out_unshown_picker_and_drops_its_late_result() -> None:
     window = _PickerWindow()
-    clock = _Clock()
-    selections = _FileSelections(window, timeout_seconds=1.0, clock=clock)
-    selections.request(_request("open-1"))
+    window.request_file_selector(_request("open-1"))
+    window.now = FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
+    window._expire_file_selectors()
+    assert _statuses(window) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
 
-    clock.now = 1.0
-    kept = selections.filter([])
-    assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
-    assert selections.filter([_result("open-1")]) == []
-    selections.request(_request("open-2"))
-    assert window.started == ["open-1", "open-2"]
+    window._complete_file_selector(window.started[0][0], SelectedFilesStatus.CANCELLED)
+    assert _statuses(window) == []
 
 
-def test_session_opened_picker_waits_for_the_user_without_deadline() -> None:
+def test_window_expires_a_stuck_picker_when_the_next_request_arrives() -> None:
     window = _PickerWindow()
-    clock = _Clock()
-    selections = _FileSelections(window, timeout_seconds=1.0, clock=clock)
-    selections.request(_request("open-1"))
-    assert selections.filter([_opened("open-1"), _opened("other")]) == []
-
-    clock.now = 100.0
-    assert selections.filter([]) == []
-    kept = selections.filter([_result("open-1")])
-    assert _statuses(kept) == [("open-1", SelectedFilesStatus.CANCELLED)]
-
-
-def test_session_passes_through_immediate_results_and_other_input() -> None:
-    selections = _FileSelections(NullClientWindow(), clock=_Clock())
-    selections.request(_request("open-1"))
-    close = CloseUserInputEvent(timestamp=uint64(0))
-    kept = selections.filter([close])
-    assert _statuses(kept) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
-    assert kept[-1] is close
-    selections.request(_request("open-2"))
-    assert _statuses(selections.filter([])) == [
-        ("open-2", SelectedFilesStatus.UNAVAILABLE)
-    ]
+    window.request_file_selector(_request("open-1"))
+    window.now = FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
+    window.request_file_selector(_request("open-2"))
+    assert _statuses(window) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
+    assert [request_id for _, request_id in window.started] == ["open-1", "open-2"]
+
+
+def test_window_shown_picker_waits_for_the_user_without_deadline() -> None:
+    window = _PickerWindow()
+    window.request_file_selector(_request("open-1"))
+    window._file_selector_opened(window.started[0][0])
+    window.now = 1_000.0
+    window._expire_file_selectors()
+    assert _statuses(window) == []
+
+
+def test_flush_forgets_the_open_picker_without_a_result() -> None:
+    window = _PickerWindow()
+    window.request_file_selector(_request("open-1"))
+    window.flush_file_selectors()
+    window._complete_file_selector(window.started[0][0], SelectedFilesStatus.CANCELLED)
+    assert _statuses(window) == []
+    assert window.cancelled == 1
+
+    window.flush_file_selectors()
+    assert window.cancelled == 1
+    window.request_file_selector(_request("open-1"))
+    assert len(window.started) == 2
+
+
+def test_window_answers_unavailable_when_its_picker_fails_to_start() -> None:
+    class _BrokenWindow(NullClientWindow):
+        def _request_file_selector(
+            self, selector_id: int, request: FileSelectionRequest
+        ) -> None:
+            raise RuntimeError("no picker")
+
+    window = _BrokenWindow()
+    window.request_file_selector(_request("open-1"))
+    assert _statuses(window) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
 
 
 def test_selected_file_policy_helpers() -> None:
@@ -286,55 +287,22 @@ def test_selected_file_policy_helpers() -> None:
     )
 
 
-def test_ui_loop_does_not_queue_when_open_is_false() -> None:
-    loop = _ui_loop()
-    assert loop.file_selector("open-1") is None
-    assert loop.flush_ui_loop_requests() is None
-
-
-def test_ui_loop_returns_this_tick_selected_files_event() -> None:
-    loop = _ui_loop()
-    event = SelectedFilesUserInputEvent(
-        timestamp=uint64(1),
-        request_id="open-1",
-        status=SelectedFilesStatus.OK,
-        files=(SelectedFile(name="seed.png", data=b"png"),),
-    )
-    other = SelectedFilesUserInputEvent(
-        timestamp=uint64(2),
-        request_id="open-2",
-        status=SelectedFilesStatus.CANCELLED,
-    )
-    loop.user_events = UserInputEvents([event, other])
-
-    assert loop.file_selector("open-1") is event
-    assert loop.file_selector("open-2") is other
-    assert loop.file_selector("open-3") is None
-    assert loop.flush_ui_loop_requests() is None
-
-
 def test_ui_loop_rejects_empty_request_id() -> None:
     loop = _ui_loop()
     with pytest.raises(ValueError, match="non-empty string"):
-        loop.file_selector("")
+        loop.request_file_selector("")
 
 
 def test_ui_loop_rejects_invalid_accept() -> None:
     loop = _ui_loop()
     with pytest.raises(ValueError, match="accept suffixes"):
-        loop.file_selector("open-1", open=True, accept=("png",))
+        loop.request_file_selector("open-1", accept=("png",))
 
 
 def test_ui_loop_rejects_invalid_multiple() -> None:
     loop = _ui_loop()
     with pytest.raises(TypeError, match="multiple must be a bool"):
-        loop.file_selector("open-1", open=True, multiple=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
-
-
-def test_ui_loop_rejects_invalid_open() -> None:
-    loop = _ui_loop()
-    with pytest.raises(TypeError, match="open must be a bool"):
-        loop.file_selector("open-1", open=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+        loop.request_file_selector("open-1", multiple=1)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
 
 
 def test_selected_files_event_rejects_inconsistent_status() -> None:
@@ -360,11 +328,8 @@ def test_window_without_a_selector_answers_unavailable(
     window = (
         Mp4ClientWindow(tmp_path / "clip.mp4") if kind == "mp4" else NullClientWindow()
     )
-    pick = window.request_selected_files(
+    window.request_file_selector(
         FileSelectionRequest(request_id="open-1", initial_path="/tmp")
     )
 
-    assert pick is not None
-    assert pick.request_id == "open-1"
-    assert pick.status is SelectedFilesStatus.UNAVAILABLE
-    assert pick.files == ()
+    assert _statuses(window) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index 103ea2b30..7bdad4abd 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -669,6 +669,7 @@ def __init__(
         self.results: list[StepResult] = []
         self.cursor_requests: list[tuple[str, bool]] = []
         self.file_selection_requests: list[FileSelectionRequest] = []
+        self._file_events: list[UserInputEvent] = []
 
     def request_hide_cursor(self, hide_cursor: bool) -> None:
         """Record one cursor visibility request."""
@@ -680,20 +681,25 @@ def request_lock_cursor_to_window(self, lock_cursor_to_window: bool) -> None:
         self._log.record("window.request_lock_cursor_to_window")
         self.cursor_requests.append(("lock", lock_cursor_to_window))
 
-    def request_selected_files(
-        self, request: FileSelectionRequest
-    ) -> SelectedFilesUserInputEvent | None:
+    def request_file_selector(self, request: FileSelectionRequest) -> None:
         """Record one file-selector request and answer with the default."""
-        self._log.record("window.request_selected_files")
+        self._log.record("window.request_file_selector")
         self.file_selection_requests.append(request)
-        return super().request_selected_files(request)
+        super().request_file_selector(request)
+
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        with self._lock:
+            self._file_events.append(event)
 
     def get_user_input_events(self) -> UserInputEvents:
         self._log.record("window.get_user_input_events")
         with self._lock:
+            file_events, self._file_events = self._file_events, []
             if self._scripted:
-                return self._scripted.pop(0)
-        return UserInputEvents([])
+                return UserInputEvents(
+                    [*file_events, *self._scripted.pop(0).get_events()]
+                )
+        return UserInputEvents(file_events)
 
     def open(self, session_desc: SessionDesc) -> None:
         self._log.record("window.open")
@@ -1392,10 +1398,9 @@ def init(self) -> None:
             super().init()
 
             def open_selector(_: object) -> None:
-                self.ui_loop.file_selector(
+                self.ui_loop.request_file_selector(
                     "open-1",
                     "/tmp",
-                    open=True,
                     accept=(".png",),
                     max_file_bytes=1024,
                 )
@@ -1413,7 +1418,7 @@ def open_selector(_: object) -> None:
             max_bytes=1024,
         )
     ]
-    assert "window.request_selected_files" in log.calls
+    assert "window.request_file_selector" in log.calls
 
 
 def test_run_session_delivers_an_immediate_file_selection_result() -> None:
@@ -1422,10 +1427,14 @@ def test_run_session_delivers_an_immediate_file_selection_result() -> None:
 
     class PickingSession(FakeSession):
         def run_ui(self, step_index: int, events: UserInputEvents) -> list[StepResult]:
-            pick = self.ui_loop.file_selector("open-1", open=self.ui_steps == 0)
+            if self.ui_steps == 0:
+                self.ui_loop.request_file_selector("open-1")
             self.ui_steps += 1
-            if pick is not None:
-                picks.append(pick)
+            picks.extend(
+                event
+                for event in self.ui_loop.user_events.get_events()
+                if isinstance(event, SelectedFilesUserInputEvent)
+            )
             return super().run_ui(step_index, events)
 
     session_desc = replace(
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 39c927782..172f52b41 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -43,7 +43,6 @@
 from flashdreams.runtime_v2.session_desc import PresentationMode, SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
-    FileSelectorOpenedUserInputEvent,
     FocusUserInputEvent,
     GamepadUserInputEvent,
     GameWheelUserInputEvent,
@@ -80,23 +79,27 @@ def _files_url(window: WebRTCClientWindow, request_id: str) -> str:
     return f"{window.server.url}api/files?request_id={request_id}"
 
 
-async def _wait_file_armed(window: WebRTCClientWindow, request_id: str) -> None:
+async def _wait_file_armed(window: WebRTCClientWindow) -> str:
+    """Return the id the browser was sent once a selector is armed."""
     for _ in range(100):
-        if request_id in window.server._pending_file_requests:
-            return
+        if window.server._pending_file_requests:
+            return next(iter(window.server._pending_file_requests))
         await asyncio.sleep(0.01)
     raise AssertionError("file selection was not armed")
 
 
-def _arm(window: WebRTCClientWindow, request: FileSelectionRequest) -> None:
-    """Arm upload policy as if the browser had been sent ``request``."""
-    window.server._pending_file_requests[request.request_id] = (
-        webrtc_server._PendingFileSelection(
-            accept=request.accept,
-            max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
-            multiple=request.multiple,
-        )
+def _arm(window: WebRTCClientWindow, request: FileSelectionRequest) -> str:
+    """Arm a selector as if the browser had been sent ``request``; return its id."""
+    selector_id = window._last_file_selector_id + 1
+    window._last_file_selector_id = selector_id
+    window._active_file_selector = (selector_id, request)
+    wire_id = str(selector_id)
+    window.server._pending_file_requests[wire_id] = webrtc_server._PendingFileSelection(
+        accept=request.accept,
+        max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
+        multiple=request.multiple,
     )
+    return wire_id
 
 
 async def _post_selected_file(
@@ -123,8 +126,8 @@ async def test_file_upload_accepts_multiple_files() -> None:
     window.open(_session_desc())
     peer, _, _ = await _connect_browser(window)
     try:
-        window.request_selected_files(_file_request("open-1", multiple=True))
-        await _wait_file_armed(window, "open-1")
+        window.request_file_selector(_file_request("open-1", multiple=True))
+        wire_id = await _wait_file_armed(window)
         form = FormData()
         form.add_field(
             "file",
@@ -139,7 +142,7 @@ async def test_file_upload_accepts_multiple_files() -> None:
             content_type="application/octet-stream",
         )
         async with ClientSession() as client:
-            async with client.post(_files_url(window, "open-1"), data=form) as response:
+            async with client.post(_files_url(window, wire_id), data=form) as response:
                 assert response.status == 204
         event = await _wait_selected_files_event(window)
         assert event.status is SelectedFilesStatus.OK
@@ -246,7 +249,7 @@ async def test_file_selector_without_a_viewer_is_unavailable() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        window.request_selected_files(_file_request("open-1"))
+        window.request_file_selector(_file_request("open-1"))
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
         assert event.status is SelectedFilesStatus.UNAVAILABLE
@@ -262,26 +265,14 @@ async def test_peer_loss_completes_armed_file_selections_as_unavailable() -> Non
     peer: RTCPeerConnection | None = None
     try:
         peer, _, _ = await _connect_browser(window)
-        window.request_selected_files(_file_request("open-1"))
-        window.request_selected_files(_file_request("open-2"))
-        await _wait_file_armed(window, "open-2")
+        window.request_file_selector(_file_request("open-1"))
+        await _wait_file_armed(window)
         await peer.close()
         peer = None
 
-        events = []
-        for _ in range(100):
-            events.extend(window.get_user_input_events().get_events())
-            if len(events) >= 2:
-                break
-            await asyncio.sleep(0.01)
-        picks = [
-            event for event in events if isinstance(event, SelectedFilesUserInputEvent)
-        ]
-        assert [event.request_id for event in picks] == ["open-1", "open-2"]
-        assert all(
-            event.status is SelectedFilesStatus.UNAVAILABLE and event.files == ()
-            for event in picks
-        )
+        event = await _wait_selected_files_event(window)
+        assert event.request_id == "open-1"
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
         assert window.server._pending_file_requests == {}
     finally:
         if peer is not None:
@@ -298,8 +289,8 @@ async def test_in_flight_upload_finishes_once_after_peer_loss(
     peer: RTCPeerConnection | None = None
     try:
         peer, _, _ = await _connect_browser(window)
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        window.request_file_selector(_file_request("open-1"))
+        wire_id = await _wait_file_armed(window)
         original_multipart = web.Request.multipart
         disconnected = False
 
@@ -313,7 +304,7 @@ async def multipart_after_disconnect(request: web.Request) -> Any:
             return await original_multipart(request)
 
         monkeypatch.setattr(web.Request, "multipart", multipart_after_disconnect)
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
+        assert await _post_selected_file(window, wire_id, b"hello", "hello.txt") == 204
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
         assert event.status is SelectedFilesStatus.OK
@@ -336,7 +327,7 @@ async def test_unsolicited_file_upload_is_rejected() -> None:
             content_type="text/plain",
         )
         async with ClientSession() as client:
-            async with client.post(_files_url(window, "open-1"), data=form) as response:
+            async with client.post(_files_url(window, "1"), data=form) as response:
                 assert response.status == 409
         assert window.get_user_input_events().get_events() == []
     finally:
@@ -357,7 +348,7 @@ def on_message(message: object) -> None:
             if isinstance(message, str):
                 messages.append(json.loads(message))
 
-        window.request_selected_files(
+        window.request_file_selector(
             _file_request(
                 "open-1",
                 "/home/secret",
@@ -372,7 +363,7 @@ def on_message(message: object) -> None:
         payload = next(item for item in messages if item.get("type") == "file_selector")
         assert payload == {
             "type": "file_selector",
-            "id": "open-1",
+            "id": "1",
             "accept": [".png", ".jpg"],
             "max_bytes": MAX_SELECTED_FILE_BYTES,
             "multiple": False,
@@ -403,11 +394,11 @@ async def test_file_upload_without_file_is_unavailable() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1"))
+        wire_id = _arm(window, _file_request("open-1"))
         form = FormData()
         form.add_field("not_file", "hello")
         async with ClientSession() as client:
-            async with client.post(_files_url(window, "open-1"), data=form) as response:
+            async with client.post(_files_url(window, wire_id), data=form) as response:
                 assert response.status == 400
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
@@ -422,8 +413,8 @@ async def test_file_upload_rejects_oversize() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1", max_bytes=1))
-        status = await _post_selected_file(window, "open-1", b"x" * 8192, "big.bin")
+        wire_id = _arm(window, _file_request("open-1", max_bytes=1))
+        status = await _post_selected_file(window, wire_id, b"x" * 8192, "big.bin")
         assert status == 413
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
@@ -441,14 +432,14 @@ async def test_file_upload_stops_once_the_batch_exceeds_its_cap(
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1", multiple=True))
+        wire_id = _arm(window, _file_request("open-1", multiple=True))
         form = FormData()
         for name in ("a.bin", "b.bin", "c.bin"):
             form.add_field(
                 "file", b"xyz", filename=name, content_type="application/octet-stream"
             )
         async with ClientSession() as client:
-            async with client.post(_files_url(window, "open-1"), data=form) as response:
+            async with client.post(_files_url(window, wire_id), data=form) as response:
                 assert response.status == 413
         event = await _wait_selected_files_event(window)
         assert event.status is SelectedFilesStatus.TOO_LARGE
@@ -465,14 +456,14 @@ async def test_file_upload_over_the_batch_cap_still_reports_a_disallowed_type(
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1", accept=(".bin",), multiple=True))
+        wire_id = _arm(window, _file_request("open-1", accept=(".bin",), multiple=True))
         form = FormData()
         for name in ("a.bin", "b.bin", "c.exe"):
             form.add_field(
                 "file", b"xyz", filename=name, content_type="application/octet-stream"
             )
         async with ClientSession() as client:
-            async with client.post(_files_url(window, "open-1"), data=form) as response:
+            async with client.post(_files_url(window, wire_id), data=form) as response:
                 assert response.status == 204
         event = await _wait_selected_files_event(window)
         assert event.status is SelectedFilesStatus.DISALLOWED_TYPE
@@ -485,7 +476,7 @@ async def test_file_upload_decodes_base64_transfer_encoding() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1"))
+        wire_id = _arm(window, _file_request("open-1"))
         boundary = "----flashdreams"
         body = (
             f"--{boundary}\r\n"
@@ -497,7 +488,7 @@ async def test_file_upload_decodes_base64_transfer_encoding() -> None:
         ).encode()
         async with ClientSession() as client:
             async with client.post(
-                _files_url(window, "open-1"),
+                _files_url(window, wire_id),
                 data=body,
                 headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
             ) as response:
@@ -515,10 +506,10 @@ async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1", accept=(".png",), max_bytes=1))
+        wire_id = _arm(window, _file_request("open-1", accept=(".png",), max_bytes=1))
         assert (
             await _post_selected_file(
-                window, "open-1", b"x" * (2 * 1024 * 1024), "hello.txt"
+                window, wire_id, b"x" * (2 * 1024 * 1024), "hello.txt"
             )
             == 204
         )
@@ -537,24 +528,21 @@ async def test_browser_ack_reports_the_file_selector_opened() -> None:
     peer: RTCPeerConnection | None = None
     try:
         peer, channel, _ = await _connect_browser(window)
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        window.request_file_selector(_file_request("open-1"))
+        wire_id = await _wait_file_armed(window)
         channel.send(json.dumps({"type": "file_selector_ack", "id": "other"}))
-        channel.send(json.dumps({"type": "file_selector_ack", "id": "open-1"}))
-        opened: list[object] = []
+        channel.send(json.dumps({"type": "file_selector_ack", "id": wire_id}))
         for _ in range(100):
-            opened.extend(window.get_user_input_events().get_events())
-            if opened:
+            if window._file_selector_deadline is None:
                 break
             await asyncio.sleep(0.01)
-        assert len(opened) == 1
-        assert isinstance(opened[0], FileSelectorOpenedUserInputEvent)
-        assert opened[0].request_id == "open-1"
+        assert window._file_selector_deadline is None
+        assert window.get_user_input_events().get_events() == []
         channel.send(
             json.dumps(
                 {
                     "type": "file_selector_result",
-                    "id": "open-1",
+                    "id": wire_id,
                     "status": "cancelled",
                 }
             )
@@ -575,13 +563,13 @@ async def test_browser_file_selector_result_reports_status() -> None:
     peer: RTCPeerConnection | None = None
     try:
         peer, channel, _ = await _connect_browser(window)
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        window.request_file_selector(_file_request("open-1"))
+        wire_id = await _wait_file_armed(window)
         channel.send(
             json.dumps(
                 {
                     "type": "file_selector_result",
-                    "id": "open-1",
+                    "id": wire_id,
                     "status": "cancelled",
                 }
             )
@@ -612,13 +600,13 @@ def on_message(message: object) -> None:
                 if payload.get("type") == "error":
                     errors.append(payload)
 
-        window.request_selected_files(_file_request("open-1"))
-        await _wait_file_armed(window, "open-1")
+        window.request_file_selector(_file_request("open-1"))
+        wire_id = await _wait_file_armed(window)
         channel.send(
             json.dumps(
                 {
                     "type": "file_selector_result",
-                    "id": "open-1",
+                    "id": wire_id,
                     "status": "ok",
                 }
             )
@@ -630,7 +618,7 @@ def on_message(message: object) -> None:
         assert errors
         assert "POST /api/files" in str(errors[0].get("message"))
         assert window.get_user_input_events().get_events() == []
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 204
+        assert await _post_selected_file(window, wire_id, b"hello", "hello.txt") == 204
         event = await _wait_selected_files_event(window)
         assert event.status is SelectedFilesStatus.OK
         assert event.files[0].data == b"hello"
@@ -667,10 +655,10 @@ async def test_session_handoff_clears_pending_file_selection() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        _arm(window, _file_request("open-1"))
+        wire_id = _arm(window, _file_request("open-1"))
         window.open(_session_desc())
         assert window.server._pending_file_requests == {}
-        assert await _post_selected_file(window, "open-1", b"hello", "hello.txt") == 409
+        assert await _post_selected_file(window, wire_id, b"hello", "hello.txt") == 409
     finally:
         window.close()
 
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index ae7ad0755..b671eb734 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -10,11 +10,9 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
 - `imgui-ui-text-input` renders an editable text field over model output.
 - `imgui-ui-file-picker` opens the client file selector and shows the chosen
   name and size on one status line per button. Each Open button calls
-  `file_selector` every UI tick with its own stable `request_id`; the returned
-  event carries the file bytes. Extra
-  clicks on the same button while a picker is open are ignored. One picker is
-  open at a time; opening another meanwhile reports it as unavailable.
-  Dropping the WebRTC tab completes in-flight picks as unavailable. A picker
+  `request_file_selector` with its own `request_id`, and the result event
+  carrying that id updates the button's line. One picker is open at a time;
+  clicks on any button while it is open are ignored. Dropping the WebRTC tab completes in-flight picks as unavailable. A picker
   the host never shows within 30 seconds also completes as unavailable; a
   picker that is shown stays open as long as the user wants.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index 3a4838feb..ad87a3def 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -47,7 +47,7 @@
     ),
     SelectedFilesStatus.UNAVAILABLE: (
         "SelectedFilesStatus.UNAVAILABLE: picker could not complete "
-        "(another picker open, no or gone client, failed chooser, or "
+        "(no or gone client, picker not shown in time, failed chooser, or "
         "unreadable file)."
     ),
 }
@@ -140,24 +140,22 @@ def step_ui(
         events: UserInputEvents,
     ) -> Tensor | None:
         """Draw the Open buttons and one status line per button."""
-        del step_index, events
+        del step_index
+        for event in events.get_events():
+            if isinstance(event, SelectedFilesUserInputEvent):
+                self.state.statuses[event.request_id] = _status_text(event)
         imgui.set_next_window_pos(imgui.ImVec2(16.0, 16.0), imgui.Cond_.once)
         imgui.set_next_window_size(imgui.ImVec2(520.0, 300.0), imgui.Cond_.once)
         imgui.begin("File picker")
         try:
-            clicked = [imgui.button(label) for label, _, _ in _FILE_SELECTOR_SLOTS]
-            for (_, request_id, multiple), pressed in zip(
-                _FILE_SELECTOR_SLOTS, clicked, strict=True
-            ):
-                pick = self.file_selector(
-                    request_id,
-                    open=pressed,
-                    accept=(".bin", ".raw"),
-                    max_file_bytes=MAX_SELECTED_FILE_BYTES,
-                    multiple=multiple,
-                )
-                if pick is not None:
-                    self.state.statuses[request_id] = _status_text(pick)
+            for label, request_id, multiple in _FILE_SELECTOR_SLOTS:
+                if imgui.button(label):
+                    self.request_file_selector(
+                        request_id,
+                        accept=(".bin", ".raw"),
+                        max_file_bytes=MAX_SELECTED_FILE_BYTES,
+                        multiple=multiple,
+                    )
             for label, request_id, _ in _FILE_SELECTOR_SLOTS:
                 status = self.state.statuses.get(request_id, _NO_FILE_SELECTED)
                 line = f"{label}: {status}"

From 35f355d8820192c7f753b0298338ab83774986d7 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 15 Oct 2026 11:42:58 -0700
Subject: [PATCH 40/43] Keep one file selection per UI tick

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/loop.py        | 13 ++++++-----
 .../flashdreams/runtime_v2/session_runner.py  |  4 ++--
 flashdreams/test_v2/test_selected_files.py    | 15 ++++++-------
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py | 22 ++++++++++---------
 4 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 36b2d32b9..6727a7f28 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -103,8 +103,8 @@ class UILoopRequests:
     new_window_size: tuple[int, int] | None = None
     """Requested downstream window size, or ``None`` to leave it unchanged."""
 
-    file_selections: list[FileSelectionRequest] = field(default_factory=list)
-    """File-selector requests to apply, in the order they were queued."""
+    file_selection: FileSelectionRequest | None = None
+    """File selector to show, or ``None`` when none was requested."""
 
 
 class ILoop(ABC, Generic[StateT]):
@@ -613,7 +613,8 @@ def request_file_selector(
         :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`
         in :attr:`user_events`, carrying ``request_id``. Read its ``status``;
         use ``files`` only when the pick succeeded. One selector is open at a
-        time: a request made while one is open is ignored and gets no result.
+        time: a request made while one is open, or after another request in
+        the same tick, is ignored and gets no result.
 
         Example:
 
@@ -669,15 +670,15 @@ def request_file_selector(
                 raise ValueError("max_file_bytes must be > 0.")
         if not isinstance(multiple, bool):
             raise TypeError("multiple must be a bool.")
-        self.get_or_create_ui_loop_requests().file_selections.append(
-            FileSelectionRequest(
+        requests = self.get_or_create_ui_loop_requests()
+        if requests.file_selection is None:
+            requests.file_selection = FileSelectionRequest(
                 request_id=request_id,
                 initial_path=resolved_initial_path,
                 accept=suffixes,
                 max_bytes=max_file_bytes,
                 multiple=multiple,
             )
-        )
 
     def get_or_create_ui_loop_requests(self) -> UILoopRequests:
         if self._ui_loop_requests is None:
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 6c481929c..a36a48161 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -448,8 +448,8 @@ def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> No
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
-    for file_selection in request.file_selections:
-        window.request_file_selector(file_selection)
+    if request.file_selection is not None:
+        window.request_file_selector(request.file_selection)
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 3c6237cd0..02e5069cc 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -74,8 +74,8 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    assert len(requests.file_selections) == 1
-    selection = requests.file_selections[0]
+    selection = requests.file_selection
+    assert selection is not None
     assert selection.request_id == "open-1"
     assert selection.initial_path == "/tmp"
     assert selection.accept == (".png", ".JPG")
@@ -89,20 +89,19 @@ def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    assert requests.file_selections[0].initial_path == str(Path.home())
+    assert requests.file_selection is not None
+    assert requests.file_selection.initial_path == str(Path.home())
 
 
-def test_ui_loop_forwards_distinct_file_selection_ids() -> None:
+def test_ui_loop_keeps_the_first_file_selection_of_a_tick() -> None:
     loop = _ui_loop()
     loop.request_file_selector("open-1", "/tmp")
     loop.request_file_selector("open-2", "/var")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == [
-        "open-1",
-        "open-2",
-    ]
+    assert requests.file_selection is not None
+    assert requests.file_selection.request_id == "open-1"
 
 
 def test_ui_loop_keeps_file_results_until_a_step_runs() -> None:
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 8ab6d52db..2ff0595f7 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -118,10 +118,12 @@ def test_open_file_button_requests_a_client_file(label: str, request_id: str) ->
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == [request_id]
-    assert requests.file_selections[0].accept == (".bin", ".raw")
-    assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
-    assert requests.file_selections[0].multiple is False
+    selection = requests.file_selection
+    assert selection is not None
+    assert selection.request_id == request_id
+    assert selection.accept == (".bin", ".raw")
+    assert selection.max_bytes == MAX_SELECTED_FILE_BYTES
+    assert selection.multiple is False
 
 
 def test_open_files_button_requests_multiple_client_files() -> None:
@@ -132,12 +134,12 @@ def test_open_files_button_requests_multiple_client_files() -> None:
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None
-    assert [item.request_id for item in requests.file_selections] == [
-        _OPEN_FILES_REQUEST_ID
-    ]
-    assert requests.file_selections[0].accept == (".bin", ".raw")
-    assert requests.file_selections[0].max_bytes == MAX_SELECTED_FILE_BYTES
-    assert requests.file_selections[0].multiple is True
+    selection = requests.file_selection
+    assert selection is not None
+    assert selection.request_id == _OPEN_FILES_REQUEST_ID
+    assert selection.accept == (".bin", ".raw")
+    assert selection.max_bytes == MAX_SELECTED_FILE_BYTES
+    assert selection.multiple is True
 
 
 def test_selected_files_event_updates_file_picker_status() -> None:

From 290d81d321583d41006dc9feffee66c11a2d788f Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 15 Oct 2026 11:50:52 -0700
Subject: [PATCH 41/43] Drop stale file selector id comment

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/runtime_v2/serving/web/app.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 6faa93d43..e08afdde2 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -329,9 +329,6 @@ const openFileSelector = options => {
   if (typeof requestId !== "string" || !requestId) {
     return;
   }
-  // ponytail: replies carry only the request id, so a prompt left open across a
-  // session handoff can answer the next session's request for the same id.
-  // Upgrade path: tag requests with a session id and echo it in replies.
   if (pendingFileRequest !== null) {
     if (pendingFileRequest.id !== requestId) {
       completeFileSelection(requestId, "unavailable");

From be952ac6e09c4ac5d21efeaf5d8516703c6e59e2 Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 15 Oct 2026 14:02:37 -0700
Subject: [PATCH 42/43] Harden file selection and document its contract

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 flashdreams/flashdreams/api_v2/README.md      |  18 ++--
 .../flashdreams/api_v2/client_window.py       |  35 +++---
 flashdreams/flashdreams/api_v2/loop.py        |  66 +++++++++---
 flashdreams/flashdreams/runtime_v2/README.md  |  26 +++--
 .../runtime_v2/mp4_client_window.py           |   1 +
 .../runtime_v2/native_window_client_window.py |   9 +-
 .../runtime_v2/null_client_window.py          |   1 +
 .../flashdreams/runtime_v2/selected_file.py   |   2 +-
 .../flashdreams/runtime_v2/serving/web/app.js |   9 +-
 .../runtime_v2/serving/webrtc_server.py       | 100 +++++++++++-------
 .../flashdreams/runtime_v2/session_runner.py  |   3 +-
 .../runtime_v2/webrtc_client_window.py        |   6 +-
 .../test_native_window_client_window.py       |  11 ++
 flashdreams/test_v2/test_selected_files.py    |   8 ++
 flashdreams/test_v2/test_session_runner.py    |  17 ++-
 .../test_v2/test_webrtc_client_window.py      |  64 +++++++----
 16 files changed, 257 insertions(+), 119 deletions(-)

diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index 219d4ac9b..b9c286f04 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -226,18 +226,12 @@ description; the runtime cleans the current session and passes that description
 to `ApplicationRunner` unchanged. Remaining timeout and remaining model steps
 still apply to the replacement. To let the user pick a client file, call
 `request_file_selector(request_id, ...)` when they ask (for ImGui, when
-`imgui.button(...)` returns `True`). The result arrives on a later tick as one
-`SelectedFilesUserInputEvent` in the UI loop's events, carrying that
-`request_id`, so each place that can open a picker should pass its own id. Read
-`status`; use `files` only when the pick succeeded. `accept` is filename
-suffixes (empty = any type);
-`max_file_bytes` is the size budget per file (`None` = the
-`MAX_SELECTED_FILE_BYTES` ceiling); `multiple` allows more than one file, with
-the whole set capped by `MAX_SELECTED_FILE_BATCH_BYTES`. Both caps live in
-`runtime_v2/selected_file.py`. One picker is open at a time; a request made
-while another is open is ignored and gets no result. The status is
-`UNAVAILABLE` when the client cannot show a picker, or does not show one within
-30 seconds. Once a picker is shown, the user may take as long as they want.
+`imgui.button(...)` returns `True`), with one stable `request_id` per control.
+The result arrives on a later tick as one `SelectedFilesUserInputEvent`
+carrying that `request_id`; read its `status` before its `files`. One picker
+is open at a time, and a call made while one is open gets no event. The
+`request_file_selector` docstring is the full contract: timing, every status,
+size and type limits, and what WebRTC shows.
 
 For SlangPy's smaller retained widget API, subclass `SlangPyUILoop` from
 `flashdreams.runtime_v2.slangpy_ui_loop`. The
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 17d82e316..61f6bf339 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -38,8 +38,9 @@ class IClientWindow(InputSource, OutputSink, ABC):
     A window does not describe the output shape. The session does, and the window
     is given that description in :meth:`OutputSink.open`.
 
-    One thread makes every call on a window, so an implementation needs no
-    locking except when its backend delivers input from another thread.
+    The runtime makes every call on a window from one thread. A window still
+    needs locking where its backend or file picker delivers input from another
+    thread, such as :meth:`_put_user_input_event`.
 
     Created by the runtime, never by an application.
     """
@@ -111,7 +112,8 @@ def request_file_selector(self, request: FileSelectionRequest) -> None:
     def flush_file_selectors(self) -> None:
         """Forget the open picker without a result, for a session that ended.
 
-        A picker still on screen stays there; whatever it returns is dropped.
+        The window withdraws a picker still on screen where it can; whatever
+        that picker returns is dropped.
         """
         with _FILE_SELECTOR_LOCK:
             active = self._active_file_selector
@@ -136,14 +138,17 @@ def _request_file_selector(
 
     # Optional to implement
     def _cancel_active_file_selectors(self) -> None:
-        """Withdraw the picker that :meth:`flush_file_selectors` forgot."""
+        """Withdraw the picker that was flushed or that timed out."""
         pass
 
     # Optional to implement
     def _put_user_input_event(self, event: UserInputEvent) -> None:
         """Queue ``event`` for :meth:`InputSource.get_user_input_events`.
 
-        Only window code calls this. It may run on any thread.
+        Every window implements this, including one without a picker, or the
+        ``UNAVAILABLE`` answer to its requests is lost. Only window code calls
+        it. It may run on any thread and runs under the file-selector lock, so
+        it must not call back into file selection.
         """
         raise NotImplementedError(
             f"{type(self).__name__} must implement _put_user_input_event to "
@@ -172,14 +177,16 @@ def _complete_file_selector(
                 return
             self._active_file_selector = None
             self._file_selector_deadline = None
-        self._put_user_input_event(
-            SelectedFilesUserInputEvent(
-                timestamp=uint64(0),
-                request_id=active[1].request_id,
-                status=status,
-                files=files,
+            # Queued under the lock so flush_file_selectors, which runs before
+            # the next session's open(), cannot slip in before the put.
+            self._put_user_input_event(
+                SelectedFilesUserInputEvent(
+                    timestamp=uint64(0),
+                    request_id=active[1].request_id,
+                    status=status,
+                    files=files,
+                )
             )
-        )
 
     @final
     def _expire_file_selectors(self) -> None:
@@ -202,8 +209,10 @@ def _expire_file_selectors(self) -> None:
             FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
         )
         self._complete_file_selector(active[0], SelectedFilesStatus.UNAVAILABLE)
+        self._cancel_active_file_selectors()
 
 
 # ponytail: one lock for every window keeps subclasses constructor-free; it only
-# guards a few assignments. Upgrade path: a per-window lock set in ``__init__``.
+# guards a few assignments and one event put. Upgrade path: a per-window lock
+# set in ``__init__``.
 _FILE_SELECTOR_LOCK = threading.Lock()
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index 6727a7f28..ecf5c090b 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -609,36 +609,70 @@ def request_file_selector(
     ) -> None:
         """Ask the client to show a file selector.
 
-        The result arrives on a later tick as one
+        The call only queues the request and returns nothing. The window sees
+        it after this step, so the result is never in :attr:`user_events`
+        during the step that asked. It arrives on a later tick as one
         :class:`~flashdreams.runtime_v2.user_input_event.SelectedFilesUserInputEvent`
-        in :attr:`user_events`, carrying ``request_id``. Read its ``status``;
-        use ``files`` only when the pick succeeded. One selector is open at a
-        time: a request made while one is open, or after another request in
-        the same tick, is ignored and gets no result.
+        carrying ``request_id``. The model loop's ``step`` receives the same
+        event.
+
+        One selector is open at a time. A call made while one is open, or
+        after another call in the same tick, is discarded: that ``request_id``
+        gets no event and nothing is logged. Every call that is not discarded
+        gets exactly one event. Use one stable ``request_id`` per control and
+        reuse it.
+
+        Read ``status`` first. ``files`` is empty unless it is ``OK``, and one
+        rejected file fails the whole set:
+
+        - ``OK``: ``files`` holds each chosen file as its base ``name`` and its
+          ``data`` bytes. There is no host path. Empty files are allowed.
+        - ``CANCELLED``: the user dismissed the selector.
+        - ``DISALLOWED_TYPE``: a file did not match ``accept``. Suffixes
+          compare case-insensitively, and this wins over ``TOO_LARGE``.
+        - ``TOO_LARGE``: a file exceeded ``max_file_bytes``, or the set
+          exceeded
+          :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BATCH_BYTES`.
+        - ``UNAVAILABLE``: the window has no picker (MP4, null), the picker
+          was not shown within
+          :data:`~flashdreams.runtime_v2.selected_file.FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS`,
+          the viewer left, the chooser failed, or a file could not be read.
+
+        Once the picker is shown there is no deadline. On WebRTC, shown means
+        the browser's "The app requested a file" prompt; its Select… button
+        opens the browser's file chooser.
 
         Example:
 
         .. code-block:: python
 
+            from flashdreams.runtime_v2.selected_file import SelectedFilesStatus
+            from flashdreams.runtime_v2.user_input_event import (
+                SelectedFilesUserInputEvent,
+            )
+
             if imgui.button("Open image"):
                 self.request_file_selector("open-image", accept=(".png",))
             for event in self.user_events.get_events():
-                if (
-                    isinstance(event, SelectedFilesUserInputEvent)
-                    and event.request_id == "open-image"
-                    and event.status is SelectedFilesStatus.OK
-                ):
+                if not isinstance(event, SelectedFilesUserInputEvent):
+                    continue
+                if event.request_id != "open-image":
+                    continue
+                if event.status is SelectedFilesStatus.OK:
                     image_bytes = event.files[0].data
+                else:
+                    self.state.message = f"No image: {event.status.value}"
 
         Args:
-            request_id: Names the place in the UI that asked, so its result
-                can be told apart from another place's. Echoed on the result.
-            initial_path: Directory hint for the selector; ``None`` uses the
-                current user's home directory.
+            request_id: Names the control that asked, so its result can be
+                told apart from another control's. Echoed on the result.
+            initial_path: Directory hint for the native selector; ``None``
+                uses the host user's home directory. The browser ignores it.
             accept: Filename suffixes such as ``.png``. Empty allows any type.
             max_file_bytes: Maximum size of each file in bytes, or ``None`` for
-                the ceiling. Larger values clamp to
-                :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BYTES`.
+                the ceiling. Larger values are clamped to
+                :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BYTES`
+                without notice.
             multiple: Whether the selector may return more than one file. The
                 whole set is also capped by
                 :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BATCH_BYTES`.
diff --git a/flashdreams/flashdreams/runtime_v2/README.md b/flashdreams/flashdreams/runtime_v2/README.md
index f0a798a34..8b4e5ea06 100644
--- a/flashdreams/flashdreams/runtime_v2/README.md
+++ b/flashdreams/flashdreams/runtime_v2/README.md
@@ -377,16 +377,22 @@ them and hands them over in batches when the session asks.
 File selection rules live in `IClientWindow` itself: one picker at a time
 (another request while one is open is ignored), `UNAVAILABLE` if a picker is
 not shown within 30 seconds, and exactly one result per request. A window
-only shows the picker. It implements `_put_user_input_event` to queue an event
-for `get_user_input_events`; that alone is enough for a window without a
-picker, which then answers every request with `UNAVAILABLE`. A window with a
-picker also implements `_request_file_selector(selector_id, request)` without
-blocking, calls `_file_selector_opened(selector_id)` once the picker is shown,
-then `_complete_file_selector(selector_id, status, files)` from any thread, and
-calls `_expire_file_selectors()` each time its input is read. A result for a
-picker that was forgotten when its session ended is dropped. A window that
-wraps another forwards `request_file_selector` and `flush_file_selectors` to
-it instead.
+only shows the picker.
+
+Every window implements `_put_user_input_event` to queue an event for
+`get_user_input_events`. Without it, even a window with no picker loses the
+`UNAVAILABLE` answer it owes each request. It may run on any thread and is
+called under the file-selector lock, so it must not call back into file
+selection. `open()` drops events still queued for the previous session.
+
+A window with a picker also implements `_request_file_selector(selector_id,
+request)` without blocking, calls `_file_selector_opened(selector_id)` once the
+picker is shown, then `_complete_file_selector(selector_id, status, files)`
+from any thread, and calls `_expire_file_selectors()` each time its input is
+read. `_cancel_active_file_selectors()` withdraws a picker that timed out or
+was forgotten when its session ended; whatever it returns later is dropped. A
+window that wraps another forwards `request_file_selector` and
+`flush_file_selectors` to it instead.
 
 A UI loop may call `request_new_session(session_desc)` during its step with a
 fully resolved replacement description. `run_session` stops and cleans the
diff --git a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
index eec786e28..40439ffda 100644
--- a/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/mp4_client_window.py
@@ -58,6 +58,7 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
 
     def open(self, session_desc: SessionDesc) -> None:
         """Prepare to write a session's output."""
+        self._input_events = []
         self._video_sink.open(session_desc)
 
     def write(self, result: StepResult) -> None:
diff --git a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
index e083d4bbc..5709b43bf 100644
--- a/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/native_window_client_window.py
@@ -7,6 +7,7 @@
 
 import logging
 import queue
+import stat
 import threading
 import time
 from collections import deque
@@ -118,9 +119,12 @@ def _selected_files_from_paths(
     sized: list[tuple[str, int]] = []
     for path in paths:
         try:
-            sized.append((path, Path(path).stat().st_size))
+            info = Path(path).stat()
         except OSError:
             return (), SelectedFilesStatus.UNAVAILABLE
+        if not stat.S_ISREG(info.st_mode):
+            return (), SelectedFilesStatus.UNAVAILABLE
+        sized.append((path, info.st_size))
     rejected = selected_files_policy_status(
         [(Path(path).name, size) for path, size in sized],
         accept=accept,
@@ -131,7 +135,8 @@ def _selected_files_from_paths(
     files: list[SelectedFile] = []
     for path, _size in sized:
         try:
-            data = Path(path).read_bytes()
+            with open(path, "rb") as stream:
+                data = stream.read(budget + 1)
         except OSError:
             return (), SelectedFilesStatus.UNAVAILABLE
         files.append(SelectedFile(name=Path(path).name, data=data))
diff --git a/flashdreams/flashdreams/runtime_v2/null_client_window.py b/flashdreams/flashdreams/runtime_v2/null_client_window.py
index f5163217e..377889abe 100644
--- a/flashdreams/flashdreams/runtime_v2/null_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/null_client_window.py
@@ -27,6 +27,7 @@ def _put_user_input_event(self, event: UserInputEvent) -> None:
     def open(self, session_desc: SessionDesc) -> None:
         """Accept a session without opening an output."""
         del session_desc
+        self._input_events = []
 
     def write(self, result: StepResult) -> None:
         """Discard one result."""
diff --git a/flashdreams/flashdreams/runtime_v2/selected_file.py b/flashdreams/flashdreams/runtime_v2/selected_file.py
index 65d9f339c..fb613f2b1 100644
--- a/flashdreams/flashdreams/runtime_v2/selected_file.py
+++ b/flashdreams/flashdreams/runtime_v2/selected_file.py
@@ -175,7 +175,7 @@ class SelectedFile:
     """One file chosen by a client file selector."""
 
     name: str
-    """File name shown to the application."""
+    """Base name of the chosen file, without any host path."""
 
     data: bytes
     """File contents."""
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index e08afdde2..4d7592785 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -271,6 +271,9 @@ const startFileInput = pending => {
     hideFilePicker();
   };
   input.addEventListener("change", () => {
+    if (pendingFileRequest === null || pendingFileRequest.id !== requestId) {
+      return;
+    }
     const files = pending.multiple
       ? Array.from(input.files || [])
       : Array.from(input.files || []).slice(0, 1);
@@ -301,7 +304,7 @@ const startFileInput = pending => {
     for (const file of files) {
       body.append("file", file, file.name);
     }
-    fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`, {
+    fetch(`/api/files?id=${encodeURIComponent(requestId)}`, {
       method: "POST",
       body,
     })
@@ -398,6 +401,10 @@ controls.addEventListener("message", event => {
       openFileSelector(payload);
       return;
     }
+    if (payload?.type === "file_selector_cancel") {
+      hideFilePicker();
+      return;
+    }
     if (payload?.type === "error") {
       console.warn(`WebRTC server: ${payload.message ?? "unknown error"}`);
     }
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index a85a07f4e..5003a1321 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -8,6 +8,7 @@
 import asyncio
 import json
 import math
+import secrets
 import socket
 import threading
 import time
@@ -309,6 +310,9 @@ async def _next_queued_frame(self) -> _QueuedRGBFrame:
 class _PendingFileSelection:
     """Accept suffixes and size budget for one armed file-selector request."""
 
+    selector_id: str
+    """Window selector this upload answers. Never sent to the browser."""
+
     accept: tuple[str, ...]
     """Filename suffixes the client may upload, empty for any type."""
 
@@ -471,7 +475,7 @@ def _send_cursor_options(self) -> None:
         self._sent_cursor_options = cursor_options
 
     def request_file_selector(
-        self, request_id: str, request: FileSelectionRequest
+        self, selector_id: str, request: FileSelectionRequest
     ) -> None:
         """Ask the connected browser to open a file selector.
 
@@ -479,10 +483,11 @@ def request_file_selector(
         Without a connected viewer the request completes as ``UNAVAILABLE``.
 
         Args:
-            request_id: Id the browser echoes back with this selector's result.
+            selector_id: Window selector reported back with this result.
             request: File selector to show.
         """
         policy = _PendingFileSelection(
+            selector_id=selector_id,
             accept=normalize_selected_file_accept(request.accept),
             max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
             multiple=request.multiple,
@@ -490,30 +495,49 @@ def request_file_selector(
         loop = self._loop
         if loop is None:
             raise RuntimeError("WebRTC server is not running.")
-        loop.call_soon_threadsafe(self._arm_file_selector, request_id, policy)
+        loop.call_soon_threadsafe(self._arm_file_selector, policy)
 
     def cancel_file_selectors(self) -> None:
-        """Forget every armed selector; a later upload for one is refused."""
+        """Forget every armed selector and close the viewer's prompt.
+
+        A later upload for a forgotten selector is refused.
+        """
+        loop = self._loop
+        if loop is None:
+            with self._file_selector_lock:
+                self._pending_file_requests.clear()
+            return
+        # On the event loop, after any arm still queued for a forgotten selector.
+        loop.call_soon_threadsafe(self._withdraw_file_selectors)
+
+    def _withdraw_file_selectors(self) -> None:
+        """Forget armed selectors and tell the viewer to close its prompt."""
         with self._file_selector_lock:
             self._pending_file_requests.clear()
+        channel = self._control_channel
+        if channel is not None and channel.readyState == "open":
+            channel.send(json.dumps({"type": "file_selector_cancel"}))
 
-    def _arm_file_selector(
-        self, request_id: str, policy: _PendingFileSelection
-    ) -> None:
-        """Send the selector to the browser and remember its upload policy."""
+    def _arm_file_selector(self, policy: _PendingFileSelection) -> None:
+        """Send the selector to the browser and remember its upload policy.
+
+        The browser gets an unguessable token instead of the selector id, so a
+        page that cannot read the data channel cannot answer the selector.
+        """
         channel = self._control_channel
         if channel is None or channel.readyState != "open":
             self._emit_selected_files(
-                request_id, status=SelectedFilesStatus.UNAVAILABLE
+                policy.selector_id, status=SelectedFilesStatus.UNAVAILABLE
             )
             return
+        token = secrets.token_urlsafe(16)
         with self._file_selector_lock:
-            self._pending_file_requests[request_id] = policy
+            self._pending_file_requests[token] = policy
         channel.send(
             json.dumps(
                 {
                     "type": "file_selector",
-                    "id": request_id,
+                    "id": token,
                     "accept": list(policy.accept),
                     "max_bytes": policy.max_bytes,
                     "multiple": policy.multiple,
@@ -521,21 +545,19 @@ def _arm_file_selector(
             )
         )
 
-    def _take_pending_file_request(
-        self, request_id: str
-    ) -> _PendingFileSelection | None:
-        """Return and consume the policy for ``request_id``, if it was pending."""
+    def _take_pending_file_request(self, token: str) -> _PendingFileSelection | None:
+        """Return and consume the policy for ``token``, if it was pending."""
         with self._file_selector_lock:
-            return self._pending_file_requests.pop(request_id, None)
+            return self._pending_file_requests.pop(token, None)
 
     def _complete_abandoned_file_selectors(self) -> None:
         """Answer every armed pick as ``UNAVAILABLE`` because the viewer left."""
         with self._file_selector_lock:
-            abandoned = tuple(self._pending_file_requests)
+            abandoned = tuple(self._pending_file_requests.values())
             self._pending_file_requests.clear()
-        for request_id in abandoned:
+        for policy in abandoned:
             self._emit_selected_files(
-                request_id, status=SelectedFilesStatus.UNAVAILABLE
+                policy.selector_id, status=SelectedFilesStatus.UNAVAILABLE
             )
 
     def event_timestamp_us(self) -> np.uint64:
@@ -664,7 +686,7 @@ def register_file_selector_callbacks(
         opened: Callable[[str], None],
         completed: Callable[[str, SelectedFilesStatus, tuple[SelectedFile, ...]], None],
     ) -> None:
-        """Register how armed file selectors report back, by request id.
+        """Register how armed file selectors report back, by selector id.
 
         Both run on the server thread.
 
@@ -891,14 +913,12 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
             raise web.HTTPServiceUnavailable(reason="WebRTC server is closed.")
         if self._timestamp_us() is None:
             raise web.HTTPConflict(reason="WebRTC server is not open.")
-        request_id = request.query.get("request_id")
-        if not isinstance(request_id, str) or not request_id:
-            raise web.HTTPBadRequest(reason="File upload requires request_id.")
-        policy = self._take_pending_file_request(request_id)
+        token = request.query.get("id")
+        if not isinstance(token, str) or not token:
+            raise web.HTTPBadRequest(reason="File upload requires an id.")
+        policy = self._take_pending_file_request(token)
         if policy is None:
-            raise web.HTTPConflict(
-                reason="No pending file selection for this request_id."
-            )
+            raise web.HTTPConflict(reason="No pending file selection for this id.")
 
         emitted = False
 
@@ -907,7 +927,7 @@ def emit(
             files: tuple[SelectedFile, ...] = (),
         ) -> None:
             nonlocal emitted
-            self._emit_selected_files(request_id, status=status, files=files)
+            self._emit_selected_files(policy.selector_id, status=status, files=files)
             emitted = True
 
         try:
@@ -1307,19 +1327,20 @@ def _buffer_browser_message(
         elif event_type == "close":
             event = CloseUserInputEvent(timestamp=timestamp_us)
         elif event_type == "file_selector_ack":
-            request_id = payload.get("id")
-            if not isinstance(request_id, str) or not request_id:
+            token = payload.get("id")
+            if not isinstance(token, str) or not token:
                 raise ValueError(
                     "File selector acknowledgement requires a non-empty id."
                 )
             with self._file_selector_lock:
-                if request_id not in self._pending_file_requests:
-                    return
-            self._file_selector_callbacks_or_raise()[0](request_id)
+                policy = self._pending_file_requests.get(token)
+            if policy is None:
+                return
+            self._file_selector_callbacks_or_raise()[0](policy.selector_id)
             return
         elif event_type == "file_selector_result":
-            request_id = payload.get("id")
-            if not isinstance(request_id, str) or not request_id:
+            token = payload.get("id")
+            if not isinstance(token, str) or not token:
                 raise ValueError("File selector result requires a non-empty id.")
             try:
                 status = SelectedFilesStatus(payload.get("status"))
@@ -1330,9 +1351,10 @@ def _buffer_browser_message(
                     "File selector result must not set status ok; send files "
                     "with POST /api/files."
                 )
-            if self._take_pending_file_request(request_id) is None:
+            policy = self._take_pending_file_request(token)
+            if policy is None:
                 return
-            self._emit_selected_files(request_id, status=status)
+            self._emit_selected_files(policy.selector_id, status=status)
             return
         else:
             raise ValueError("Unsupported browser event type.")
@@ -1347,13 +1369,13 @@ def _append_event(self, event: UserInputEvent) -> None:
 
     def _emit_selected_files(
         self,
-        request_id: str,
+        selector_id: str,
         *,
         status: SelectedFilesStatus,
         files: tuple[SelectedFile, ...] = (),
     ) -> None:
         """Report the result of one armed file selector to the window."""
-        self._file_selector_callbacks_or_raise()[1](request_id, status, files)
+        self._file_selector_callbacks_or_raise()[1](selector_id, status, files)
 
     def _file_selector_callbacks_or_raise(
         self,
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index a36a48161..78432fe5b 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -448,7 +448,8 @@ def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> No
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
-    if request.file_selection is not None:
+    # A replacement flushes the selector before it could be answered.
+    if request.file_selection is not None and request.new_session is None:
         window.request_file_selector(request.file_selection)
 
 
diff --git a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
index 9143ed8b7..c98a58dc0 100644
--- a/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
+++ b/flashdreams/flashdreams/runtime_v2/webrtc_client_window.py
@@ -73,9 +73,9 @@ def handle_input(event: UserInputEvent) -> None:
 
         self.server.register_input_callback(handle_input)
         self.server.register_file_selector_callbacks(
-            opened=lambda request_id: self._file_selector_opened(int(request_id)),
-            completed=lambda request_id, status, files: self._complete_file_selector(
-                int(request_id), status, files
+            opened=lambda selector_id: self._file_selector_opened(int(selector_id)),
+            completed=lambda selector_id, status, files: self._complete_file_selector(
+                int(selector_id), status, files
             ),
         )
 
diff --git a/flashdreams/test_v2/test_native_window_client_window.py b/flashdreams/test_v2/test_native_window_client_window.py
index 82f074ee0..18ad9e763 100644
--- a/flashdreams/test_v2/test_native_window_client_window.py
+++ b/flashdreams/test_v2/test_native_window_client_window.py
@@ -821,6 +821,17 @@ def test_selected_files_from_paths_skips_unreadable_and_oversize(
     assert status is SelectedFilesStatus.DISALLOWED_TYPE
 
 
+@pytest.mark.skipif(not Path("/dev/zero").exists(), reason="needs /dev/zero")
+def test_selected_files_from_paths_rejects_a_non_regular_file(tmp_path: Path) -> None:
+    endless = tmp_path / "endless.bin"
+    endless.symlink_to("/dev/zero")
+    files, status = native_window_module._selected_files_from_paths(
+        (str(endless),), accept=(".bin",)
+    )
+    assert files == ()
+    assert status is SelectedFilesStatus.UNAVAILABLE
+
+
 def test_native_window_shown_picker_has_no_deadline(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index 02e5069cc..dea038295 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -173,11 +173,19 @@ def test_window_times_out_unshown_picker_and_drops_its_late_result() -> None:
     window.now = FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS
     window._expire_file_selectors()
     assert _statuses(window) == [("open-1", SelectedFilesStatus.UNAVAILABLE)]
+    assert window.cancelled == 1
 
     window._complete_file_selector(window.started[0][0], SelectedFilesStatus.CANCELLED)
     assert _statuses(window) == []
 
 
+def test_null_window_open_drops_a_result_left_by_the_previous_session() -> None:
+    window = NullClientWindow()
+    window.request_file_selector(_request("open-1"))
+    window.open(SessionDesc())
+    assert _statuses(window) == []
+
+
 def test_window_expires_a_stuck_picker_when_the_next_request_arrives() -> None:
     window = _PickerWindow()
     window.request_file_selector(_request("open-1"))
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index 7bdad4abd..bf48d5df6 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -21,6 +21,7 @@
     IModelLoop,
     IUILoop,
     ModelInferenceState,
+    UILoopRequests,
     invoke_async,
 )
 from flashdreams.api_v2.session import ISession
@@ -44,7 +45,7 @@
     PresentationMode,
     SessionDesc,
 )
-from flashdreams.runtime_v2.session_runner import run_session
+from flashdreams.runtime_v2.session_runner import _apply_window_requests, run_session
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
     CloseUserInputEvent,
@@ -1421,6 +1422,20 @@ def open_selector(_: object) -> None:
     assert "window.request_file_selector" in log.calls
 
 
+def test_window_requests_skip_a_file_selector_for_a_replaced_session() -> None:
+    window = RecordingClientWindow(CallLog())
+    _apply_window_requests(
+        window,
+        UILoopRequests(
+            new_session=_session_desc(),
+            file_selection=FileSelectionRequest(
+                request_id="open-1", initial_path="/tmp"
+            ),
+        ),
+    )
+    assert window.file_selection_requests == []
+
+
 def test_run_session_delivers_an_immediate_file_selection_result() -> None:
     log = CallLog()
     picks: list[SelectedFilesUserInputEvent] = []
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index 172f52b41..edd774f22 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -75,12 +75,12 @@ def _file_request(
     )
 
 
-def _files_url(window: WebRTCClientWindow, request_id: str) -> str:
-    return f"{window.server.url}api/files?request_id={request_id}"
+def _files_url(window: WebRTCClientWindow, token: str) -> str:
+    return f"{window.server.url}api/files?id={token}"
 
 
 async def _wait_file_armed(window: WebRTCClientWindow) -> str:
-    """Return the id the browser was sent once a selector is armed."""
+    """Return the token the browser was sent once a selector is armed."""
     for _ in range(100):
         if window.server._pending_file_requests:
             return next(iter(window.server._pending_file_requests))
@@ -89,12 +89,13 @@ async def _wait_file_armed(window: WebRTCClientWindow) -> str:
 
 
 def _arm(window: WebRTCClientWindow, request: FileSelectionRequest) -> str:
-    """Arm a selector as if the browser had been sent ``request``; return its id."""
+    """Arm a selector as if the browser had been sent ``request``; return its token."""
     selector_id = window._last_file_selector_id + 1
     window._last_file_selector_id = selector_id
     window._active_file_selector = (selector_id, request)
-    wire_id = str(selector_id)
+    wire_id = f"token-{selector_id}"
     window.server._pending_file_requests[wire_id] = webrtc_server._PendingFileSelection(
+        selector_id=str(selector_id),
         accept=request.accept,
         max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
         multiple=request.multiple,
@@ -315,21 +316,15 @@ async def multipart_after_disconnect(request: web.Request) -> Any:
 
 
 @pytest.mark.asyncio
-async def test_unsolicited_file_upload_is_rejected() -> None:
+async def test_upload_without_the_armed_token_is_rejected() -> None:
     window = WebRTCClientWindow()
     window.open(_session_desc())
     try:
-        form = FormData()
-        form.add_field(
-            "file",
-            b"hello",
-            filename="hello.txt",
-            content_type="text/plain",
-        )
-        async with ClientSession() as client:
-            async with client.post(_files_url(window, "1"), data=form) as response:
-                assert response.status == 409
+        assert await _post_selected_file(window, "1", b"hello", "hello.txt") == 409
+        _arm(window, _file_request("open-1"))
+        assert await _post_selected_file(window, "1", b"hello", "hello.txt") == 409
         assert window.get_user_input_events().get_events() == []
+        assert len(window.server._pending_file_requests) == 1
     finally:
         window.close()
 
@@ -361,9 +356,11 @@ def on_message(message: object) -> None:
                 break
             await asyncio.sleep(0.01)
         payload = next(item for item in messages if item.get("type") == "file_selector")
+        token = payload.pop("id")
+        assert isinstance(token, str) and len(token) >= 16
+        assert token in window.server._pending_file_requests
         assert payload == {
             "type": "file_selector",
-            "id": "1",
             "accept": [".png", ".jpg"],
             "max_bytes": MAX_SELECTED_FILE_BYTES,
             "multiple": False,
@@ -374,6 +371,35 @@ def on_message(message: object) -> None:
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_flushed_file_selector_closes_the_browser_prompt() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    peer: RTCPeerConnection | None = None
+    try:
+        peer, channel, _ = await _connect_browser(window)
+        messages: list[dict[str, object]] = []
+
+        @channel.on("message")
+        def on_message(message: object) -> None:
+            if isinstance(message, str):
+                messages.append(json.loads(message))
+
+        window.request_file_selector(_file_request("open-1"))
+        await _wait_file_armed(window)
+        window.flush_file_selectors()
+        for _ in range(100):
+            if any(item.get("type") == "file_selector_cancel" for item in messages):
+                break
+            await asyncio.sleep(0.01)
+        assert {"type": "file_selector_cancel"} in messages
+        assert window.server._pending_file_requests == {}
+    finally:
+        if peer is not None:
+            await peer.close()
+        window.close()
+
+
 async def _wait_selected_files_event(
     window: WebRTCClientWindow,
 ) -> SelectedFilesUserInputEvent:
@@ -639,9 +665,7 @@ async def test_browser_script_checks_type_and_size_before_upload() -> None:
         assert "file.size" in script
         assert '"too_large"' in script
         assert '"disallowed_type"' in script
-        assert (
-            "fetch(`/api/files?request_id=${encodeURIComponent(requestId)}`" in script
-        )
+        assert "fetch(`/api/files?id=${encodeURIComponent(requestId)}`" in script
         assert "input.multiple" in script
         assert "file_selector_ack" in script
         assert "event.stopImmediatePropagation();" in script

From 4d0ededa27d1e6f66d7ff4160e0e4ab0e0f5e96e Mon Sep 17 00:00:00 2001
From: Set Paing <spaing@nvidia.com>
Date: Thu, 15 Oct 2026 14:57:47 -0700
Subject: [PATCH 43/43] Answer busy file selections and check results in
 IClientWindow

Signed-off-by: Set Paing <spaing@nvidia.com>
---
 apps/action2v/tests/test_application.py       |   4 +
 apps/t2v/t2v/testing.py                       |   4 +
 apps/t2v/tests/test_cli.py                    |   4 +
 .../demo_api/api_reference/application.md     |  64 +++++++++
 flashdreams/flashdreams/api_v2/README.md      |   2 +-
 .../flashdreams/api_v2/client_window.py       | 129 ++++++++++++++----
 flashdreams/flashdreams/api_v2/loop.py        |  41 ++++--
 flashdreams/flashdreams/runtime_v2/README.md  |  26 +---
 .../flashdreams/runtime_v2/selected_file.py   |  42 ++----
 .../flashdreams/runtime_v2/serving/web/app.js |   9 +-
 .../runtime_v2/serving/webrtc_server.py       |  28 +++-
 .../flashdreams/runtime_v2/session_runner.py  |   7 +-
 .../test_v2/test_application_runner.py        |   4 +
 flashdreams/test_v2/test_cli.py               |   4 +
 flashdreams/test_v2/test_client_window.py     |   4 +
 flashdreams/test_v2/test_selected_files.py    | 117 ++++++++++++----
 flashdreams/test_v2/test_session_runner.py    |   6 +-
 .../test_v2/test_webrtc_client_window.py      |  57 ++++----
 flashdreams/tests/test_profiler.py            |   4 +
 integrations_v2/imgui_ui_demo/README.md       |   2 +-
 .../imgui_ui_demo/file_picker_app.py          |   8 +-
 .../imgui_ui_demo/tests/test_imgui_ui_demo.py |   6 +-
 .../red_screen/tests/test_red_screen.py       |   4 +
 tests/test_step_agreement.py                  |   3 +
 24 files changed, 411 insertions(+), 168 deletions(-)

diff --git a/apps/action2v/tests/test_application.py b/apps/action2v/tests/test_application.py
index c767d5950..e1dbf23dc 100644
--- a/apps/action2v/tests/test_application.py
+++ b/apps/action2v/tests/test_application.py
@@ -22,6 +22,7 @@
 from numpy import uint64
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.session_runner import run_session
 from flashdreams.runtime_v2.step_result import StepResult
@@ -138,6 +139,9 @@ def __init__(self) -> None:
         self.opened = False
         self.cursor_requests: list[tuple[str, bool]] = []
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         del session_desc
         self.opened = True
diff --git a/apps/t2v/t2v/testing.py b/apps/t2v/t2v/testing.py
index 648639a68..a20337d9c 100644
--- a/apps/t2v/t2v/testing.py
+++ b/apps/t2v/t2v/testing.py
@@ -21,6 +21,7 @@
 import torch
 
 from flashdreams.api_v2.client_window import IClientWindow
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.blit_model_output_to_screen_loop import (
     BlitModelOutputToScreenLoop,
 )
@@ -410,6 +411,9 @@ class _DiscardingClientWindow(IClientWindow):
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         del session_desc
 
diff --git a/apps/t2v/tests/test_cli.py b/apps/t2v/tests/test_cli.py
index 8521ddeea..0cadccec3 100644
--- a/apps/t2v/tests/test_cli.py
+++ b/apps/t2v/tests/test_cli.py
@@ -27,6 +27,7 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.loop import IModelLoop
 from flashdreams.api_v2.session import ISession
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2 import cli
 from flashdreams.runtime_v2.application_registry import (
     APPLICATION_ENTRY_POINT_GROUP,
@@ -160,6 +161,9 @@ def __init__(self) -> None:
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
 
diff --git a/docs/source/documentation/demo_api/api_reference/application.md b/docs/source/documentation/demo_api/api_reference/application.md
index 3ba277494..a8b6246a2 100644
--- a/docs/source/documentation/demo_api/api_reference/application.md
+++ b/docs/source/documentation/demo_api/api_reference/application.md
@@ -330,6 +330,70 @@ Request a positive downstream client-window width and height.
 - `TypeError`: The size is not a pair of integers.
 - `ValueError`: Either dimension is not positive.
 
+#### `request_file_selector`
+
+```python
+def request_file_selector(self, request_id: str, initial_path: str | None=None, *, accept: Sequence[str]=(), max_file_bytes: int | None=None, multiple: bool=False) -> None
+```
+
+Ask the client to show a file selector. The call only queues the request; the
+result arrives on a later tick as one `SelectedFilesUserInputEvent` in
+`user_events`, carrying `request_id`. The model loop receives the same event.
+
+Every call gets exactly one event unless its session is replaced or shut down
+first. One selector is open at a time: a call made while one is open, including
+a second call in the same tick, is answered `BUSY`. Use one stable
+`request_id` per control.
+
+Read `status` (`SelectedFilesStatus`) before `files`; `files` is empty unless
+the status is `OK`:
+
+- `OK`: each `SelectedFile` has a base `name` (no host path) and its `data`
+  bytes.
+- `CANCELLED`: the user dismissed the selector.
+- `BUSY`: another selector was open, so this one was not shown.
+- `DISALLOWED_TYPE`: a file did not match `accept` (case-insensitive suffixes).
+- `TOO_LARGE`: a file exceeded `max_file_bytes`, or the set exceeded
+  `MAX_SELECTED_FILE_BATCH_BYTES` (256 MiB) or `MAX_SELECTED_FILE_COUNT` (256).
+- `UNAVAILABLE`: no picker (MP4, null), the picker was not shown within 30
+  seconds, the viewer left, the chooser failed, or a file could not be read.
+
+`accept` checks filename suffixes only, so validate `data` as untrusted input.
+`max_file_bytes` above `MAX_SELECTED_FILE_BYTES` (32 MiB) is clamped.
+`initial_path` is a directory hint for the native Tk dialog and is ignored by
+the browser.
+
+```python
+from flashdreams.runtime_v2.selected_file import SelectedFilesStatus
+from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
+
+if imgui.button("Open image"):
+    self.request_file_selector("open-image", accept=(".png",))
+for event in self.user_events.get_events():
+    if not isinstance(event, SelectedFilesUserInputEvent):
+        continue
+    if event.request_id != "open-image":
+        continue
+    if event.status is SelectedFilesStatus.OK:
+        image_bytes = event.files[0].data
+    else:
+        self.state.message = f"No image: {event.status.value}"
+```
+
+**Parameters**
+
+- `request_id`: Names the control that asked; echoed on the result.
+- `initial_path`: Native directory hint; `None` uses the host user's home.
+- `accept`: Filename suffixes such as `.png`. Empty allows any type.
+- `max_file_bytes`: Maximum size of each file, or `None` for the ceiling.
+- `multiple`: Whether the selector may return more than one file.
+
+**Raises**
+
+- `TypeError`: An argument has the wrong type.
+- `ValueError`: `request_id` or `initial_path` is empty, or `accept` /
+  `max_file_bytes` is invalid.
+
 #### `get_or_create_ui_loop_requests`
 
 ```python
diff --git a/flashdreams/flashdreams/api_v2/README.md b/flashdreams/flashdreams/api_v2/README.md
index b9c286f04..89d530104 100644
--- a/flashdreams/flashdreams/api_v2/README.md
+++ b/flashdreams/flashdreams/api_v2/README.md
@@ -229,7 +229,7 @@ still apply to the replacement. To let the user pick a client file, call
 `imgui.button(...)` returns `True`), with one stable `request_id` per control.
 The result arrives on a later tick as one `SelectedFilesUserInputEvent`
 carrying that `request_id`; read its `status` before its `files`. One picker
-is open at a time, and a call made while one is open gets no event. The
+is open at a time, and a call made while one is open is answered `BUSY`. The
 `request_file_selector` docstring is the full contract: timing, every status,
 size and type limits, and what WebRTC shows.
 
diff --git a/flashdreams/flashdreams/api_v2/client_window.py b/flashdreams/flashdreams/api_v2/client_window.py
index 61f6bf339..8d54fffa7 100644
--- a/flashdreams/flashdreams/api_v2/client_window.py
+++ b/flashdreams/flashdreams/api_v2/client_window.py
@@ -6,8 +6,9 @@
 import logging
 import threading
 import time
-from abc import ABC
+from abc import ABC, abstractmethod
 from collections.abc import Callable
+from dataclasses import replace
 from typing import final
 
 from numpy import uint64
@@ -17,6 +18,8 @@
     FileSelectionRequest,
     SelectedFile,
     SelectedFilesStatus,
+    clamp_selected_file_max_bytes,
+    selected_files_policy_status,
 )
 from flashdreams.runtime_v2.user_input_event import SelectedFilesUserInputEvent
 
@@ -42,6 +45,40 @@ class IClientWindow(InputSource, OutputSink, ABC):
     needs locking where its backend or file picker delivers input from another
     thread, such as :meth:`_put_user_input_event`.
 
+    File selection lifecycle. This class holds the rules; a window only shows
+    a picker and reports what it returned.
+
+    - **Request.** The runtime calls :meth:`request_file_selector` on the UI
+      thread, once for each call an app made, except in a tick that also
+      replaces the session (that session gets no results). The first request
+      opens a picker
+      with a new internal ``selector_id``. A request made while a picker is
+      open is answered at once as ``BUSY``.
+    - **Showing.** :meth:`_request_file_selector` runs on the UI thread and
+      must not block. The window calls :meth:`_file_selector_opened` from any
+      thread once the picker is on screen, which ends its deadline.
+    - **Deadline.** A picker not shown within
+      :data:`FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS` completes as
+      ``UNAVAILABLE``. :meth:`_expire_file_selectors` checks it; a window with a
+      picker calls it each time its input is read, or that answer waits for the
+      next request.
+    - **Result.** The window calls :meth:`_complete_file_selector` from any
+      thread. This class checks the result against the request (non-``OK``
+      results carry no files; ``OK`` needs files that pass ``accept``, the
+      clamped size limits, and ``multiple``) and queues exactly one event
+      through :meth:`_put_user_input_event`. A result for a ``selector_id``
+      that is no longer active is dropped.
+    - **Withdrawal.** :meth:`_cancel_active_file_selectors` runs on the UI
+      thread after a timeout or a flush, so the window can close what it shows.
+    - **Session end.** When a session ends, for replacement or shutdown, the
+      runtime calls :meth:`flush_file_selectors`: the open picker is withdrawn
+      and its result is dropped. :meth:`OutputSink.open` drops events still
+      queued for the previous session. An in-session reset
+      (``ResetUserInputEvent``) does not flush; the picker stays open and its
+      result arrives after the reset.
+    - **Wrappers.** A window that wraps another forwards
+      :meth:`request_file_selector` and :meth:`flush_file_selectors` to it.
+
     Created by the runtime, never by an application.
     """
 
@@ -66,12 +103,6 @@ def request_new_window_size(self, new_window_size: tuple[int, int]) -> None:
         """
         pass
 
-    # File selection. The public methods below hold the rules: one picker at a
-    # time, a deadline until the picker is shown, and one result per request.
-    # A window with a picker implements the ``_request_file_selector`` hook and
-    # reports through ``_file_selector_opened`` and ``_complete_file_selector``.
-    # A window that wraps another overrides the public methods to forward them.
-
     # Plain class defaults so subclasses need no constructor call; assigning
     # one on an instance shadows it for that window only.
     _active_file_selector: tuple[int, FileSelectionRequest] | None = None
@@ -84,10 +115,8 @@ def request_file_selector(self, request: FileSelectionRequest) -> None:
 
         The result is one ``SelectedFilesUserInputEvent`` from
         :meth:`InputSource.get_user_input_events` carrying
-        ``request.request_id``. While a picker is open, another request is
-        ignored. A picker not shown within
-        :data:`FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS` completes as
-        ``UNAVAILABLE``; once shown, the user may take as long as they want.
+        ``request.request_id``. A request made while a picker is open is
+        answered as ``BUSY``. See the class docstring for the lifecycle.
 
         Args:
             request: Selector request queued by the UI loop.
@@ -95,6 +124,9 @@ def request_file_selector(self, request: FileSelectionRequest) -> None:
         self._expire_file_selectors()
         with _FILE_SELECTOR_LOCK:
             if self._active_file_selector is not None:
+                self._put_user_input_event(
+                    _selected_files_event(request, SelectedFilesStatus.BUSY)
+                )
                 return
             selector_id = self._last_file_selector_id + 1
             self._last_file_selector_id = selector_id
@@ -141,19 +173,15 @@ def _cancel_active_file_selectors(self) -> None:
         """Withdraw the picker that was flushed or that timed out."""
         pass
 
-    # Optional to implement
+    @abstractmethod
     def _put_user_input_event(self, event: UserInputEvent) -> None:
         """Queue ``event`` for :meth:`InputSource.get_user_input_events`.
 
-        Every window implements this, including one without a picker, or the
-        ``UNAVAILABLE`` answer to its requests is lost. Only window code calls
-        it. It may run on any thread and runs under the file-selector lock, so
-        it must not call back into file selection.
+        Required even for a window without a picker, which answers every
+        request through it. Only this class calls it. It may run on any thread
+        and runs under the file-selector lock, so it must not call back into
+        file selection.
         """
-        raise NotImplementedError(
-            f"{type(self).__name__} must implement _put_user_input_event to "
-            "report file selections."
-        )
 
     @final
     def _file_selector_opened(self, selector_id: int) -> None:
@@ -170,23 +198,22 @@ def _complete_file_selector(
         status: SelectedFilesStatus,
         files: tuple[SelectedFile, ...] = (),
     ) -> None:
-        """Report the result for ``selector_id``; a stale id is dropped."""
+        """Report the result for ``selector_id``; a stale id is dropped.
+
+        A result that breaks the request's rules is reported by the status it
+        earns instead; see the class docstring.
+        """
         with _FILE_SELECTOR_LOCK:
             active = self._active_file_selector
             if active is None or active[0] != selector_id:
                 return
             self._active_file_selector = None
             self._file_selector_deadline = None
+            request = active[1]
+            status, files = _checked_result(request, status, files)
             # Queued under the lock so flush_file_selectors, which runs before
             # the next session's open(), cannot slip in before the put.
-            self._put_user_input_event(
-                SelectedFilesUserInputEvent(
-                    timestamp=uint64(0),
-                    request_id=active[1].request_id,
-                    status=status,
-                    files=files,
-                )
-            )
+            self._put_user_input_event(_selected_files_event(request, status, files))
 
     @final
     def _expire_file_selectors(self) -> None:
@@ -212,6 +239,50 @@ def _expire_file_selectors(self) -> None:
         self._cancel_active_file_selectors()
 
 
+def _selected_files_event(
+    request: FileSelectionRequest,
+    status: SelectedFilesStatus,
+    files: tuple[SelectedFile, ...] = (),
+) -> SelectedFilesUserInputEvent:
+    """Return the event answering ``request``."""
+    return SelectedFilesUserInputEvent(
+        timestamp=uint64(0),
+        request_id=request.request_id,
+        status=status,
+        files=files,
+    )
+
+
+def _checked_result(
+    request: FileSelectionRequest,
+    status: SelectedFilesStatus,
+    files: tuple[SelectedFile, ...],
+) -> tuple[SelectedFilesStatus, tuple[SelectedFile, ...]]:
+    """Return the status and files a window's result earns under ``request``."""
+    if status is SelectedFilesStatus.BUSY:
+        status = SelectedFilesStatus.UNAVAILABLE
+    if status is not SelectedFilesStatus.OK:
+        return status, ()
+    if not files or (len(files) > 1 and not request.multiple):
+        _LOGGER.warning("File selector %r returned no valid set.", request.request_id)
+        return SelectedFilesStatus.UNAVAILABLE, ()
+    files = tuple(replace(chosen, name=_base_name(chosen.name)) for chosen in files)
+    rejected = selected_files_policy_status(
+        [(chosen.name, len(chosen.data)) for chosen in files],
+        accept=request.accept,
+        max_bytes=clamp_selected_file_max_bytes(request.max_bytes),
+    )
+    if rejected is not None:
+        return rejected, ()
+    return status, files
+
+
+def _base_name(name: str) -> str:
+    """Return ``name`` without any POSIX or Windows directory part."""
+    base = name.replace("\\", "/").rsplit("/", 1)[-1]
+    return "upload" if base in ("", ".", "..") else base
+
+
 # ponytail: one lock for every window keeps subclasses constructor-free; it only
 # guards a few assignments and one event put. Upgrade path: a per-window lock
 # set in ``__init__``.
diff --git a/flashdreams/flashdreams/api_v2/loop.py b/flashdreams/flashdreams/api_v2/loop.py
index ecf5c090b..b16d241ba 100644
--- a/flashdreams/flashdreams/api_v2/loop.py
+++ b/flashdreams/flashdreams/api_v2/loop.py
@@ -103,8 +103,8 @@ class UILoopRequests:
     new_window_size: tuple[int, int] | None = None
     """Requested downstream window size, or ``None`` to leave it unchanged."""
 
-    file_selection: FileSelectionRequest | None = None
-    """File selector to show, or ``None`` when none was requested."""
+    file_selections: list[FileSelectionRequest] = field(default_factory=list)
+    """File-selector requests in call order. The window answers each one."""
 
 
 class ILoop(ABC, Generic[StateT]):
@@ -263,7 +263,8 @@ def _finish_run(
             self.latest_result = result
             self._pending_user_events.clear()
         else:
-            # A file result arrives once, so keep it until a step can read it.
+            # Input that reaches a run with no step is dropped, except a file
+            # result: it answers a request and arrives once.
             self._pending_user_events = [
                 event
                 for event in self._pending_user_events
@@ -616,11 +617,16 @@ def request_file_selector(
         carrying ``request_id``. The model loop's ``step`` receives the same
         event.
 
-        One selector is open at a time. A call made while one is open, or
-        after another call in the same tick, is discarded: that ``request_id``
-        gets no event and nothing is logged. Every call that is not discarded
-        gets exactly one event. Use one stable ``request_id`` per control and
-        reuse it.
+        Every call gets exactly one event, unless the session ends first: a
+        session replaced or shut down before the answer gets none. One
+        selector is open at a time, so a call made while one is open, including
+        a second call in the same tick, is answered ``BUSY``. Use one stable
+        ``request_id`` per control and reuse it. A control that is already
+        waiting for its own result can get a ``BUSY`` for a repeat click
+        before that result.
+
+        For the full lifecycle, including session reset versus replacement,
+        see :class:`~flashdreams.api_v2.client_window.IClientWindow`.
 
         Read ``status`` first. ``files`` is empty unless it is ``OK``, and one
         rejected file fails the whole set:
@@ -628,19 +634,28 @@ def request_file_selector(
         - ``OK``: ``files`` holds each chosen file as its base ``name`` and its
           ``data`` bytes. There is no host path. Empty files are allowed.
         - ``CANCELLED``: the user dismissed the selector.
+        - ``BUSY``: another selector was open, so this one was not shown.
         - ``DISALLOWED_TYPE``: a file did not match ``accept``. Suffixes
           compare case-insensitively, and this wins over ``TOO_LARGE``.
         - ``TOO_LARGE``: a file exceeded ``max_file_bytes``, or the set
           exceeded
-          :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BATCH_BYTES`.
+          :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_BATCH_BYTES`
+          or :data:`~flashdreams.runtime_v2.selected_file.MAX_SELECTED_FILE_COUNT`.
         - ``UNAVAILABLE``: the window has no picker (MP4, null), the picker
           was not shown within
           :data:`~flashdreams.runtime_v2.selected_file.FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS`,
           the viewer left, the chooser failed, or a file could not be read.
 
+        ``accept`` checks filename suffixes only, never contents, so validate
+        and decode ``data`` as untrusted input.
+
         Once the picker is shown there is no deadline. On WebRTC, shown means
         the browser's "The app requested a file" prompt; its Select… button
-        opens the browser's file chooser.
+        opens the browser's file chooser. The native window uses a Tk dialog,
+        which needs a Python with Tk and a display; without them the result is
+        ``UNAVAILABLE``. Tk cannot close its dialog from another thread, so one
+        left open when its session ends stays on screen, and whatever it
+        returns is dropped.
 
         Example:
 
@@ -704,15 +719,15 @@ def request_file_selector(
                 raise ValueError("max_file_bytes must be > 0.")
         if not isinstance(multiple, bool):
             raise TypeError("multiple must be a bool.")
-        requests = self.get_or_create_ui_loop_requests()
-        if requests.file_selection is None:
-            requests.file_selection = FileSelectionRequest(
+        self.get_or_create_ui_loop_requests().file_selections.append(
+            FileSelectionRequest(
                 request_id=request_id,
                 initial_path=resolved_initial_path,
                 accept=suffixes,
                 max_bytes=max_file_bytes,
                 multiple=multiple,
             )
+        )
 
     def get_or_create_ui_loop_requests(self) -> UILoopRequests:
         if self._ui_loop_requests is None:
diff --git a/flashdreams/flashdreams/runtime_v2/README.md b/flashdreams/flashdreams/runtime_v2/README.md
index 8b4e5ea06..731fe2ca2 100644
--- a/flashdreams/flashdreams/runtime_v2/README.md
+++ b/flashdreams/flashdreams/runtime_v2/README.md
@@ -374,25 +374,13 @@ chooses its UI independently of the client window. Browser keyboard, mouse,
 focus, and file-selector events arrive on the server's own thread, so it queues
 them and hands them over in batches when the session asks.
 
-File selection rules live in `IClientWindow` itself: one picker at a time
-(another request while one is open is ignored), `UNAVAILABLE` if a picker is
-not shown within 30 seconds, and exactly one result per request. A window
-only shows the picker.
-
-Every window implements `_put_user_input_event` to queue an event for
-`get_user_input_events`. Without it, even a window with no picker loses the
-`UNAVAILABLE` answer it owes each request. It may run on any thread and is
-called under the file-selector lock, so it must not call back into file
-selection. `open()` drops events still queued for the previous session.
-
-A window with a picker also implements `_request_file_selector(selector_id,
-request)` without blocking, calls `_file_selector_opened(selector_id)` once the
-picker is shown, then `_complete_file_selector(selector_id, status, files)`
-from any thread, and calls `_expire_file_selectors()` each time its input is
-read. `_cancel_active_file_selectors()` withdraws a picker that timed out or
-was forgotten when its session ended; whatever it returns later is dropped. A
-window that wraps another forwards `request_file_selector` and
-`flush_file_selectors` to it instead.
+File selection rules live in `IClientWindow`, and its class docstring is the
+full lifecycle: requests, the 30 second deadline, result checks, withdrawal,
+session end versus in-session reset, threads, and wrappers. A window only shows
+a picker and reports what it returned. Every window implements the abstract
+`_put_user_input_event`; a window with a picker also implements
+`_request_file_selector` and calls `_expire_file_selectors()` each time its
+input is read.
 
 A UI loop may call `request_new_session(session_desc)` during its step with a
 fully resolved replacement description. `run_session` stops and cleans the
diff --git a/flashdreams/flashdreams/runtime_v2/selected_file.py b/flashdreams/flashdreams/runtime_v2/selected_file.py
index fb613f2b1..ce100e183 100644
--- a/flashdreams/flashdreams/runtime_v2/selected_file.py
+++ b/flashdreams/flashdreams/runtime_v2/selected_file.py
@@ -15,6 +15,9 @@
 MAX_SELECTED_FILE_BATCH_BYTES = 8 * MAX_SELECTED_FILE_BYTES
 """Hard ceiling for the total bytes of one selected-files request."""
 
+MAX_SELECTED_FILE_COUNT = 256
+"""Hard ceiling for the number of files in one selected-files request."""
+
 FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS = 30.0
 """Seconds to wait for a client window to show a picker before ``UNAVAILABLE``.
 
@@ -98,44 +101,21 @@ class SelectedFilesStatus(Enum):
     """The user dismissed the selector."""
 
     TOO_LARGE = "too_large"
-    """The chosen set exceeded the size budget."""
+    """A file exceeded its size budget, or the set exceeded the batch size or
+    file-count ceiling."""
 
     DISALLOWED_TYPE = "disallowed_type"
     """A chosen file did not match ``accept``. Checked before size."""
 
+    BUSY = "busy"
+    """Another selector was already open, so this request was not shown. The
+    open selector keeps going and answers its own request."""
+
     UNAVAILABLE = "unavailable"
     """No pick was made: the client has no picker or left, the picker was not
     shown in time, or a chosen file was unreadable."""
 
 
-def selected_file_policy_status(
-    name: str,
-    size: int | None,
-    *,
-    accept: tuple[str, ...] = (),
-    max_bytes: int,
-) -> SelectedFilesStatus | None:
-    """Return why one chosen file is rejected, or ``None`` if it is allowed.
-
-    Type is checked before size. A too-large disallowed file is
-    ``DISALLOWED_TYPE``. Pass ``size=None`` to check only the name.
-
-    Args:
-        name: File name to match against ``accept``.
-        size: File size in bytes, or ``None`` to skip the size check.
-        accept: Filename suffixes such as ``.png``. Empty allows any type.
-        max_bytes: Maximum allowed size in bytes.
-
-    Returns:
-        ``DISALLOWED_TYPE``, ``TOO_LARGE``, or ``None`` when the file passes.
-    """
-    if not selected_file_suffix_allowed(name, accept):
-        return SelectedFilesStatus.DISALLOWED_TYPE
-    if size is not None and size > max_bytes:
-        return SelectedFilesStatus.TOO_LARGE
-    return None
-
-
 def selected_files_policy_status(
     files: Sequence[tuple[str, int | None]],
     *,
@@ -144,7 +124,7 @@ def selected_files_policy_status(
 ) -> SelectedFilesStatus | None:
     """Return why a chosen set is rejected, or ``None`` if every file is allowed.
 
-    Type is checked before size, across the whole set.
+    Type is checked before size and count, across the whole set.
 
     Args:
         files: ``(name, size)`` pairs. ``size`` of ``None`` skips that file's
@@ -158,6 +138,8 @@ def selected_files_policy_status(
     for name, _size in files:
         if not selected_file_suffix_allowed(name, accept):
             return SelectedFilesStatus.DISALLOWED_TYPE
+    if len(files) > MAX_SELECTED_FILE_COUNT:
+        return SelectedFilesStatus.TOO_LARGE
     total = 0
     for _name, size in files:
         if size is None:
diff --git a/flashdreams/flashdreams/runtime_v2/serving/web/app.js b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
index 4d7592785..a8129779f 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/web/app.js
+++ b/flashdreams/flashdreams/runtime_v2/serving/web/app.js
@@ -309,14 +309,17 @@ const startFileInput = pending => {
       body,
     })
       .then(response => {
+        if (!response.ok) {
+          // A proxy may refuse the upload before the server can answer it.
+          console.debug("File upload was rejected.", response.status);
+          finishFileSelection("unavailable");
+          return;
+        }
         if (settled || pendingFileRequest === null || pendingFileRequest.id !== requestId) {
           return;
         }
         settled = true;
         hideFilePicker();
-        if (!response.ok) {
-          console.debug("File upload was rejected.", response.status);
-        }
       })
       .catch(error => {
         console.debug("Unable to upload the selected file.", error);
diff --git a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
index 5003a1321..e6b802386 100644
--- a/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
+++ b/flashdreams/flashdreams/runtime_v2/serving/webrtc_server.py
@@ -32,6 +32,7 @@
 from flashdreams.runtime_v2.cuda_utils import resolve_cuda_device
 from flashdreams.runtime_v2.selected_file import (
     MAX_SELECTED_FILE_BATCH_BYTES,
+    MAX_SELECTED_FILE_COUNT,
     FileSelectionRequest,
     SelectedFile,
     SelectedFilesStatus,
@@ -376,6 +377,7 @@ def __init__(
         self._hide_cursor = False
         self._lock_cursor_to_window = False
         self._pending_file_requests: dict[str, _PendingFileSelection] = {}
+        self._uploading_file_requests: dict[str, _PendingFileSelection] = {}
         self._file_selector_callbacks: (
             tuple[
                 Callable[[str], None],
@@ -553,8 +555,12 @@ def _take_pending_file_request(self, token: str) -> _PendingFileSelection | None
     def _complete_abandoned_file_selectors(self) -> None:
         """Answer every armed pick as ``UNAVAILABLE`` because the viewer left."""
         with self._file_selector_lock:
-            abandoned = tuple(self._pending_file_requests.values())
+            abandoned = (
+                *self._pending_file_requests.values(),
+                *self._uploading_file_requests.values(),
+            )
             self._pending_file_requests.clear()
+            self._uploading_file_requests.clear()
         for policy in abandoned:
             self._emit_selected_files(
                 policy.selector_id, status=SelectedFilesStatus.UNAVAILABLE
@@ -919,6 +925,9 @@ async def _upload_selected_file(self, request: web.Request) -> web.Response:
         policy = self._take_pending_file_request(token)
         if policy is None:
             raise web.HTTPConflict(reason="No pending file selection for this id.")
+        # Tracked until it ends so a viewer that leaves mid-upload is answered.
+        with self._file_selector_lock:
+            self._uploading_file_requests[token] = policy
 
         emitted = False
 
@@ -940,6 +949,7 @@ def emit(
                 emit(SelectedFilesStatus.TOO_LARGE)
                 raise
             chosen: list[tuple[str, bytes]] = []
+            file_count = 0
             total_bytes = 0
             too_large = False
             while True:
@@ -954,6 +964,13 @@ def emit(
                 if not policy.multiple and (chosen or too_large):
                     await part.release()
                     continue
+                if not _identity_encoded(part):
+                    emit(SelectedFilesStatus.UNAVAILABLE)
+                    raise web.HTTPBadRequest(reason="File parts must not be encoded.")
+                file_count += 1
+                if file_count > MAX_SELECTED_FILE_COUNT:
+                    too_large = True
+                    chosen.clear()
                 name = part.filename or "upload"
                 if not selected_file_suffix_allowed(name, policy.accept):
                     emit(SelectedFilesStatus.DISALLOWED_TYPE)
@@ -1005,6 +1022,8 @@ def emit(
                 emit(SelectedFilesStatus.TOO_LARGE)
             raise
         finally:
+            with self._file_selector_lock:
+                self._uploading_file_requests.pop(token, None)
             if not emitted:
                 emit(SelectedFilesStatus.UNAVAILABLE)
 
@@ -1487,6 +1506,13 @@ async def _shutdown(self) -> None:
 """Bytes read per multipart chunk while enforcing ``max_bytes``."""
 
 
+def _identity_encoded(part: BodyPartReader) -> bool:
+    """Return whether ``part`` carries its bytes as-is, as browsers send them."""
+    transfer = part.headers.get("Content-Transfer-Encoding", "").lower()
+    content = part.headers.get("Content-Encoding", "").lower()
+    return transfer in ("", "binary", "7bit", "8bit") and content in ("", "identity")
+
+
 async def _read_upload_part_bounded(
     part: BodyPartReader, *, max_bytes: int
 ) -> bytes | None:
diff --git a/flashdreams/flashdreams/runtime_v2/session_runner.py b/flashdreams/flashdreams/runtime_v2/session_runner.py
index 78432fe5b..d5a331996 100644
--- a/flashdreams/flashdreams/runtime_v2/session_runner.py
+++ b/flashdreams/flashdreams/runtime_v2/session_runner.py
@@ -448,9 +448,10 @@ def _apply_window_requests(window: IClientWindow, request: UILoopRequests) -> No
         window.request_lock_cursor_to_window(request.lock_cursor_to_window)
     if request.new_window_size is not None:
         window.request_new_window_size(request.new_window_size)
-    # A replacement flushes the selector before it could be answered.
-    if request.file_selection is not None and request.new_session is None:
-        window.request_file_selector(request.file_selection)
+    # A replaced session gets no results, so its requests are not shown.
+    if request.new_session is None:
+        for file_selection in request.file_selections:
+            window.request_file_selector(file_selection)
 
 
 def _open_chunk_trace(path_value: object) -> _ChunkTraceLog:
diff --git a/flashdreams/test_v2/test_application_runner.py b/flashdreams/test_v2/test_application_runner.py
index 606c3899d..89329e07a 100644
--- a/flashdreams/test_v2/test_application_runner.py
+++ b/flashdreams/test_v2/test_application_runner.py
@@ -16,6 +16,7 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.loop import IModelLoop, IUILoop
 from flashdreams.api_v2.session import ISession
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.core.distributed.parallel import ParallelContext
 from flashdreams.runtime_v2.application_runner import ApplicationRunner
 from flashdreams.runtime_v2.metrics_output_sink import MetricsOutputSink
@@ -158,6 +159,9 @@ def get_user_input_events(self) -> UserInputEvents:
             )
         return UserInputEvents([])
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         del session_desc
         self._calls.append("window.open")
diff --git a/flashdreams/test_v2/test_cli.py b/flashdreams/test_v2/test_cli.py
index 1c8731244..839958e5c 100644
--- a/flashdreams/test_v2/test_cli.py
+++ b/flashdreams/test_v2/test_cli.py
@@ -18,6 +18,7 @@
 from flashdreams.api_v2.application import IApplication
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.session import ISession
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2 import cli, client_window_factory
 from flashdreams.runtime_v2.application_runner import ApplicationRunner, Unbound
 from flashdreams.runtime_v2.client_window_factory import ClientWindowMode
@@ -42,6 +43,9 @@ class _StubWindow(IClientWindow):
     def get_user_input_events(self) -> UserInputEvents:
         return UserInputEvents([])
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         del session_desc
 
diff --git a/flashdreams/test_v2/test_client_window.py b/flashdreams/test_v2/test_client_window.py
index 720ab4acc..7e66a592f 100644
--- a/flashdreams/test_v2/test_client_window.py
+++ b/flashdreams/test_v2/test_client_window.py
@@ -11,6 +11,7 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.input_source import InputSource
 from flashdreams.api_v2.output_sink import OutputSink
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.session_desc import SessionDesc
 from flashdreams.runtime_v2.step_result import StepResult
 from flashdreams.runtime_v2.user_input_event import (
@@ -36,6 +37,9 @@ def __init__(self) -> None:
     def get_user_input_events(self) -> UserInputEvents:
         return self._input
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
         self._is_open = True
diff --git a/flashdreams/test_v2/test_selected_files.py b/flashdreams/test_v2/test_selected_files.py
index dea038295..46c24186d 100644
--- a/flashdreams/test_v2/test_selected_files.py
+++ b/flashdreams/test_v2/test_selected_files.py
@@ -19,12 +19,12 @@
     FILE_SELECTION_PRESENTATION_TIMEOUT_SECONDS,
     MAX_SELECTED_FILE_BATCH_BYTES,
     MAX_SELECTED_FILE_BYTES,
+    MAX_SELECTED_FILE_COUNT,
     FileSelectionRequest,
     SelectedFile,
     SelectedFilesStatus,
     clamp_selected_file_max_bytes,
     normalize_selected_file_accept,
-    selected_file_policy_status,
     selected_file_suffix_allowed,
     selected_files_policy_status,
 )
@@ -74,8 +74,7 @@ def test_ui_loop_queues_file_selection_policy_without_clamping() -> None:
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    selection = requests.file_selection
-    assert selection is not None
+    [selection] = requests.file_selections
     assert selection.request_id == "open-1"
     assert selection.initial_path == "/tmp"
     assert selection.accept == (".png", ".JPG")
@@ -89,19 +88,20 @@ def test_ui_loop_uses_home_when_initial_path_is_omitted() -> None:
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    assert requests.file_selection is not None
-    assert requests.file_selection.initial_path == str(Path.home())
+    assert requests.file_selections[0].initial_path == str(Path.home())
 
 
-def test_ui_loop_keeps_the_first_file_selection_of_a_tick() -> None:
+def test_ui_loop_forwards_every_file_selection_of_a_tick() -> None:
     loop = _ui_loop()
     loop.request_file_selector("open-1", "/tmp")
     loop.request_file_selector("open-2", "/var")
 
     requests = loop.flush_ui_loop_requests()
     assert requests is not None
-    assert requests.file_selection is not None
-    assert requests.file_selection.request_id == "open-1"
+    assert [item.request_id for item in requests.file_selections] == [
+        "open-1",
+        "open-2",
+    ]
 
 
 def test_ui_loop_keeps_file_results_until_a_step_runs() -> None:
@@ -157,7 +157,10 @@ def test_window_shows_one_picker_at_a_time() -> None:
     window.request_file_selector(_request("open-1"))
     window.request_file_selector(_request("open-2"))
     assert [request_id for _, request_id in window.started] == ["open-1"]
-    assert _statuses(window) == []
+    assert _statuses(window) == [
+        ("open-1", SelectedFilesStatus.BUSY),
+        ("open-2", SelectedFilesStatus.BUSY),
+    ]
 
     selector_id = window.started[0][0]
     window._complete_file_selector(selector_id, SelectedFilesStatus.CANCELLED)
@@ -167,6 +170,82 @@ def test_window_shows_one_picker_at_a_time() -> None:
     assert [request_id for _, request_id in window.started] == ["open-1", "open-2"]
 
 
+def test_window_checks_a_result_against_its_request() -> None:
+    def complete(
+        request: FileSelectionRequest,
+        status: SelectedFilesStatus,
+        files: tuple[SelectedFile, ...],
+    ) -> list[SelectedFilesUserInputEvent]:
+        window = _PickerWindow()
+        window.request_file_selector(request)
+        window._complete_file_selector(window.started[0][0], status, files)
+        events = window.get_user_input_events().get_events()
+        selected = [e for e in events if isinstance(e, SelectedFilesUserInputEvent)]
+        assert selected == events
+        return selected
+
+    png = FileSelectionRequest(
+        request_id="open-1", initial_path="/tmp", accept=(".png",), max_bytes=4
+    )
+    a = SelectedFile(name="a.png", data=b"1")
+    b = SelectedFile(name="b.png", data=b"2")
+    cases = [
+        (png, SelectedFilesStatus.OK, (), SelectedFilesStatus.UNAVAILABLE),
+        (png, SelectedFilesStatus.OK, (a, b), SelectedFilesStatus.UNAVAILABLE),
+        (
+            png,
+            SelectedFilesStatus.OK,
+            (SelectedFile(name="a.txt", data=b"1"),),
+            SelectedFilesStatus.DISALLOWED_TYPE,
+        ),
+        (
+            png,
+            SelectedFilesStatus.OK,
+            (SelectedFile(name="a.png", data=b"12345"),),
+            SelectedFilesStatus.TOO_LARGE,
+        ),
+        (png, SelectedFilesStatus.CANCELLED, (a,), SelectedFilesStatus.CANCELLED),
+        (png, SelectedFilesStatus.BUSY, (), SelectedFilesStatus.UNAVAILABLE),
+    ]
+    for request, status, files, expected in cases:
+        [event] = complete(request, status, files)
+        assert (event.status, event.files) == (expected, ())
+
+    many = FileSelectionRequest(request_id="open-1", initial_path="/tmp", multiple=True)
+    [event] = complete(many, SelectedFilesStatus.OK, (a, b))
+    assert (event.status, event.files) == (SelectedFilesStatus.OK, (a, b))
+
+    pathy = (
+        SelectedFile(name="../outside.png", data=b"1"),
+        SelectedFile(name="C:\\dir\\in.png", data=b"2"),
+        SelectedFile(name="..", data=b"3"),
+    )
+    [event] = complete(many, SelectedFilesStatus.OK, pathy)
+    assert [chosen.name for chosen in event.files] == [
+        "outside.png",
+        "in.png",
+        "upload",
+    ]
+
+
+def test_window_without_put_user_input_event_cannot_be_created() -> None:
+    class _Incomplete(IClientWindow):
+        def get_user_input_events(self) -> UserInputEvents:
+            return UserInputEvents([])
+
+        def open(self, session_desc: SessionDesc) -> None:
+            del session_desc
+
+        def write(self, result: StepResult) -> None:
+            del result
+
+        def close(self) -> None:
+            return
+
+    with pytest.raises(TypeError, match="_put_user_input_event"):
+        _Incomplete()  # type: ignore[abstract]
+
+
 def test_window_times_out_unshown_picker_and_drops_its_late_result() -> None:
     window = _PickerWindow()
     window.request_file_selector(_request("open-1"))
@@ -241,25 +320,11 @@ def test_selected_file_policy_helpers() -> None:
     assert not selected_file_suffix_allowed("seed.txt", (".png",))
     assert selected_file_suffix_allowed("seed.txt", ())
     assert (
-        selected_file_policy_status("seed.txt", None, accept=(".png",), max_bytes=3)
-        is SelectedFilesStatus.DISALLOWED_TYPE
-    )
-    assert (
-        selected_file_policy_status("seed.png", None, accept=(".png",), max_bytes=3)
-        is None
-    )
-    assert (
-        selected_file_policy_status("seed.txt", 99, accept=(".png",), max_bytes=3)
-        is SelectedFilesStatus.DISALLOWED_TYPE
-    )
-    assert (
-        selected_file_policy_status("seed.png", 99, accept=(".png",), max_bytes=3)
+        selected_files_policy_status(
+            [("a.bin", 0)] * (MAX_SELECTED_FILE_COUNT + 1), max_bytes=3
+        )
         is SelectedFilesStatus.TOO_LARGE
     )
-    assert (
-        selected_file_policy_status("seed.png", 2, accept=(".png",), max_bytes=3)
-        is None
-    )
     assert (
         selected_files_policy_status(
             [("a.bin", 2), ("b.txt", 2)],
diff --git a/flashdreams/test_v2/test_session_runner.py b/flashdreams/test_v2/test_session_runner.py
index bf48d5df6..a97d69d33 100644
--- a/flashdreams/test_v2/test_session_runner.py
+++ b/flashdreams/test_v2/test_session_runner.py
@@ -1428,9 +1428,9 @@ def test_window_requests_skip_a_file_selector_for_a_replaced_session() -> None:
         window,
         UILoopRequests(
             new_session=_session_desc(),
-            file_selection=FileSelectionRequest(
-                request_id="open-1", initial_path="/tmp"
-            ),
+            file_selections=[
+                FileSelectionRequest(request_id="open-1", initial_path="/tmp")
+            ],
         ),
     )
     assert window.file_selection_requests == []
diff --git a/flashdreams/test_v2/test_webrtc_client_window.py b/flashdreams/test_v2/test_webrtc_client_window.py
index edd774f22..96aba7d3f 100644
--- a/flashdreams/test_v2/test_webrtc_client_window.py
+++ b/flashdreams/test_v2/test_webrtc_client_window.py
@@ -21,7 +21,7 @@
 pytest.importorskip("aiohttp")
 pytest.importorskip("aiortc")
 
-from aiohttp import ClientSession, FormData, web
+from aiohttp import ClientSession, FormData, MultipartWriter, web
 from aiortc import (
     MediaStreamTrack,
     RTCDataChannel,
@@ -282,7 +282,7 @@ async def test_peer_loss_completes_armed_file_selections_as_unavailable() -> Non
 
 
 @pytest.mark.asyncio
-async def test_in_flight_upload_finishes_once_after_peer_loss(
+async def test_in_flight_upload_is_unavailable_after_peer_loss(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     window = WebRTCClientWindow()
@@ -308,13 +308,34 @@ async def multipart_after_disconnect(request: web.Request) -> Any:
         assert await _post_selected_file(window, wire_id, b"hello", "hello.txt") == 204
         event = await _wait_selected_files_event(window)
         assert event.request_id == "open-1"
-        assert event.status is SelectedFilesStatus.OK
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+        await asyncio.sleep(0.05)
+        assert window.get_user_input_events().get_events() == []
     finally:
         if peer is not None:
             await peer.close()
         window.close()
 
 
+@pytest.mark.asyncio
+async def test_encoded_file_part_is_unavailable() -> None:
+    window = WebRTCClientWindow()
+    window.open(_session_desc())
+    try:
+        wire_id = _arm(window, _file_request("open-1"))
+        with MultipartWriter("form-data") as body:
+            part = body.append(b"abc=\n")
+            part.set_content_disposition("form-data", name="file", filename="a.bin")
+            part.headers["Content-Transfer-Encoding"] = "quoted-printable"
+        async with ClientSession() as client:
+            async with client.post(_files_url(window, wire_id), data=body) as response:
+                assert response.status == 400
+        event = await _wait_selected_files_event(window)
+        assert event.status is SelectedFilesStatus.UNAVAILABLE
+    finally:
+        window.close()
+
+
 @pytest.mark.asyncio
 async def test_upload_without_the_armed_token_is_rejected() -> None:
     window = WebRTCClientWindow()
@@ -497,36 +518,6 @@ async def test_file_upload_over_the_batch_cap_still_reports_a_disallowed_type(
         window.close()
 
 
-@pytest.mark.asyncio
-async def test_file_upload_decodes_base64_transfer_encoding() -> None:
-    window = WebRTCClientWindow()
-    window.open(_session_desc())
-    try:
-        wire_id = _arm(window, _file_request("open-1"))
-        boundary = "----flashdreams"
-        body = (
-            f"--{boundary}\r\n"
-            'Content-Disposition: form-data; name="file"; filename="seed.bin"\r\n'
-            "Content-Transfer-Encoding: base64\r\n"
-            "\r\n"
-            f"{base64.b64encode(b'abc').decode()}\r\n"
-            f"--{boundary}--\r\n"
-        ).encode()
-        async with ClientSession() as client:
-            async with client.post(
-                _files_url(window, wire_id),
-                data=body,
-                headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
-            ) as response:
-                assert response.status == 204
-        event = await _wait_selected_files_event(window)
-        assert event.status is SelectedFilesStatus.OK
-        assert event.files[0].name == "seed.bin"
-        assert event.files[0].data == b"abc"
-    finally:
-        window.close()
-
-
 @pytest.mark.asyncio
 async def test_file_upload_prefers_disallowed_suffix_over_body_limit() -> None:
     window = WebRTCClientWindow()
diff --git a/flashdreams/tests/test_profiler.py b/flashdreams/tests/test_profiler.py
index ffad1ff1e..935494a13 100644
--- a/flashdreams/tests/test_profiler.py
+++ b/flashdreams/tests/test_profiler.py
@@ -35,6 +35,7 @@
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.loop import IModelLoop
 from flashdreams.api_v2.profiler import IProfiler
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.infra import profiler as event_timer_module
 from flashdreams.runtime_v2 import profiler as profiler_module
 from flashdreams.runtime_v2.event_buffer import EventBuffer
@@ -350,6 +351,9 @@ def get_user_input_events(self) -> UserInputEvents:
         self.batches += 1
         return UserInputEvents([_key_press()])
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         pass
 
diff --git a/integrations_v2/imgui_ui_demo/README.md b/integrations_v2/imgui_ui_demo/README.md
index b671eb734..3ca20bdb9 100644
--- a/integrations_v2/imgui_ui_demo/README.md
+++ b/integrations_v2/imgui_ui_demo/README.md
@@ -12,7 +12,7 @@ Small ImGui applications for the FlashDreams v2 loop runtime:
   name and size on one status line per button. Each Open button calls
   `request_file_selector` with its own `request_id`, and the result event
   carrying that id updates the button's line. One picker is open at a time;
-  clicks on any button while it is open are ignored. Dropping the WebRTC tab completes in-flight picks as unavailable. A picker
+  a click on any button while it is open shows `BUSY` on that button's line. Dropping the WebRTC tab completes in-flight picks as unavailable. A picker
   the host never shows within 30 seconds also completes as unavailable; a
   picker that is shown stays open as long as the user wants.
 - `imgui-ui-query-string` sets background from a `?(r,g,b)` browser URL.
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
index ad87a3def..c39767795 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/file_picker_app.py
@@ -38,9 +38,13 @@
     SelectedFilesStatus.CANCELLED: (
         "SelectedFilesStatus.CANCELLED: user dismissed the selector."
     ),
+    SelectedFilesStatus.BUSY: (
+        "SelectedFilesStatus.BUSY: another picker was already open."
+    ),
     SelectedFilesStatus.TOO_LARGE: (
-        "SelectedFilesStatus.TOO_LARGE: file exceeded this request's "
-        f"max_file_bytes={MAX_SELECTED_FILE_BYTES}."
+        "SelectedFilesStatus.TOO_LARGE: a file exceeded this request's "
+        f"max_file_bytes={MAX_SELECTED_FILE_BYTES}, or the set exceeded the "
+        "batch limits."
     ),
     SelectedFilesStatus.DISALLOWED_TYPE: (
         "SelectedFilesStatus.DISALLOWED_TYPE: suffix not in accept=('.bin', '.raw')."
diff --git a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
index 2ff0595f7..ec0b2f5c1 100644
--- a/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
+++ b/integrations_v2/imgui_ui_demo/imgui_ui_demo/tests/test_imgui_ui_demo.py
@@ -118,8 +118,7 @@ def test_open_file_button_requests_a_client_file(label: str, request_id: str) ->
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None
-    selection = requests.file_selection
-    assert selection is not None
+    [selection] = requests.file_selections
     assert selection.request_id == request_id
     assert selection.accept == (".bin", ".raw")
     assert selection.max_bytes == MAX_SELECTED_FILE_BYTES
@@ -134,8 +133,7 @@ def test_open_files_button_requests_multiple_client_files() -> None:
     requests = loop.flush_ui_loop_requests()
 
     assert requests is not None
-    selection = requests.file_selection
-    assert selection is not None
+    [selection] = requests.file_selections
     assert selection.request_id == _OPEN_FILES_REQUEST_ID
     assert selection.accept == (".bin", ".raw")
     assert selection.max_bytes == MAX_SELECTED_FILE_BYTES
diff --git a/integrations_v2/red_screen/red_screen/tests/test_red_screen.py b/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
index 4dafd5952..382546640 100644
--- a/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
+++ b/integrations_v2/red_screen/red_screen/tests/test_red_screen.py
@@ -12,6 +12,7 @@
 
 from flashdreams.api_v2.client_window import IClientWindow
 from flashdreams.api_v2.session import ISession
+from flashdreams.api_v2.user_input_event import UserInputEvent
 from flashdreams.runtime_v2.session_desc import (
     BackpressureMode,
     PresentationMode,
@@ -62,6 +63,9 @@ def get_user_input_events(self) -> UserInputEvents:
                 return self._batches.pop(0)
         return UserInputEvents([])
 
+    def _put_user_input_event(self, event: UserInputEvent) -> None:
+        del event
+
     def open(self, session_desc: SessionDesc) -> None:
         self.session_desc = session_desc
         self._is_open = True
diff --git a/tests/test_step_agreement.py b/tests/test_step_agreement.py
index ba94c3b23..62ee09cff 100644
--- a/tests/test_step_agreement.py
+++ b/tests/test_step_agreement.py
@@ -164,6 +164,9 @@ def _main_thread(self):
         assert threading.get_ident() == self.session.main_thread
         assert self.session.ctx.is_main
 
+    def _put_user_input_event(self, event):
+        del event
+
     def open(self, desc):
         self._main_thread()