Fix Space RUNTIME_ERROR: publish demo=app.blocks for SpacesReloader, block_thread to stay alive

server.py

@@ -326,25 +326,35 @@ async def index():
     return FileResponse(FRONTEND / "index.html")
 
 
-# HF runs `python server.py` (README app_file) and proxies port 7860. With
-# `gradio.Server` the launch happens at MODULE TOP LEVEL (not under
-# `if __name__ == "__main__"`) — that's how a gradio-SDK Space finds and runs the
-# app (and how gradio's own reference `Server` example deploys). Two things matter:
+# HF runs `python server.py` (README app_file) and proxies port 7860. Launch
+# happens at MODULE TOP LEVEL (gradio.Server, like gradio's reference example).
+#
+# Running on a Space is fiddly because gradio *always* routes through its
+# SpacesReloader there (regardless of GRADIO_HOT_RELOAD). `launch()` starts the
+# uvicorn server AND a daemon "watch" thread (spaces.reloading) whose `postrun`
+# does `getattr(__main__, "demo")` and compares it to the live Blocks. So:
 #   * ssr_mode=False — gradio 6 defaults to SSR, which needs a Node front-proxy on
-#     7860 and pushes the Python app to 7861; on a Space (no Node) that fails the
-#     7860 health check. Disabling SSR binds the Python server directly on 7860.
-#   * we deliberately do NOT mount the legacy app.py Blocks here. A second
-#     launchable named `demo` makes the Space's gradio reloader auto-launch IT on
-#     7860, colliding with this server. The standalone Gradio UI is still
-#     available locally via `python app.py`.
-# The Space also sets GRADIO_HOT_RELOAD=false (a Space variable): with hot-reload
-# on, gradio's reloader makes launch() non-blocking and the process exits right
-# after binding 7860 (→ RUNTIME_ERROR). Disabling it lets launch() block and keeps
-# the one long-lived server alive. (Must be a Space variable, not set in-process —
-# HF sets the env in the parent before this module is imported.)
+#     7860 and pushes Python to 7861; on a Space (no Node) that fails the 7860
+#     health check. Disabling SSR binds the Python server directly on 7860.
+#   * prevent_thread_lock=True — return from launch() so we can publish `demo`
+#     before holding the thread ourselves.
+#   * `demo = app.blocks` — the watcher requires a module global named `demo` that
+#     *is* the running Blocks. gradio.Server only populates `.blocks` during
+#     launch, so we must assign it AFTER. If it's missing (or isn't the live
+#     Blocks), postrun raises / tries to swap a non-Blocks and the Space dies with
+#     RUNTIME_ERROR. We do NOT mount the legacy app.py Blocks (a second `demo`
+#     would collide); the standalone Gradio UI is still available via `python app.py`.
 app.launch(
     server_name="0.0.0.0",
     server_port=int(os.getenv("PORT", "7860")),
     ssr_mode=False,
+    prevent_thread_lock=True,
     show_error=True,
 )
+
+# Expose the live Blocks as the module global the SpacesReloader's postrun expects.
+demo = app.blocks
+
+# launch() returned (prevent_thread_lock); the server + watch threads are daemons,
+# so hold the main thread open to keep them — and the Space — alive.
+app.blocks.block_thread()