Pass file URLs between pipeline stages instead of re-uploading blobs

The JS client was re-fetching each stage's output, wrapping it as a File,
and re-uploading it to the next endpoint. The server-side preprocess then
tried to move the resulting /gradio_api/file=... URL into its cache
directory, which fails because that path doesn't exist on disk —
hence the KeyError: 'path' on the second call.

Switch the downstream endpoints (export_ply, export_viewer, export_html,
viewer_html) to take plain string URLs and return {"url": ...} dicts.
The JS client now passes each result's URL straight into the next call
via plain string parameters, no handle_file() wrapping, no re-upload.
reconstruct still uses FileData because it needs the user-uploaded bytes.

app.py

@@ -14,6 +14,8 @@ from fastapi.responses import HTMLResponse
 from gradio import Server
 from gradio.data_classes import FileData
 
+from urllib.parse import quote, urlparse
+
 from src.demo.hf_runtime import (
     InfiniSplatRuntime,
     ViewerTemplate,
@@ -44,15 +46,40 @@ def _log(stage: str, **metrics) -> None:
     print(f"INFINISPLAT_TIMING {json.dumps({'stage': stage, **metrics}, sort_keys=True)}", flush=True)
 
 
+def _file_url(path: Path) -> str:
+    """Return the public Gradio file URL for a server-side path."""
+    return f"/gradio_api/file={quote(str(path.resolve()))}"
+
+
+def _resolve_file_path(value: FileData | str) -> Path:
+    """Resolve a FileData input (or URL/path string) back to a local file path."""
+    if isinstance(value, str):
+        path_str = value
+    elif isinstance(value, dict):
+        path_str = value.get("path") or value.get("url") or ""
+    else:
+        path_str = str(value)
+    if not path_str:
+        raise ValueError(f"Cannot resolve file path from input: {value!r}")
+    # Strip Gradio's /gradio_api/file= URL prefix to get the real path
+    if path_str.startswith("/gradio_api/file="):
+        decoded = urlparse(path_str).path[len("/gradio_api/file="):]
+        return Path(decoded)
+    # Already a server-local path
+    if path_str.startswith("/"):
+        return Path(path_str)
+    return Path(path_str)
+
+
 @app.api(name="reconstruct", queue=True, concurrency_limit=1, concurrency_id="gpu")
 @spaces.GPU(duration=GPU_DURATION_SECONDS)
-def reconstruct(image_path: FileData) -> FileData:
-    """Run GPU reconstruction and return the artifact path."""
+def reconstruct(image_path: FileData) -> dict:
+    """Run GPU reconstruction and return a public URL for the artifact."""
     started = time.perf_counter()
     request_dir = OUTPUT_ROOT / uuid.uuid4().hex
     request_dir.mkdir(parents=True, exist_ok=True)
     artifact = runtime.infer_to_artifact(
-        image_path=Path(image_path["path"]),
+        image_path=_resolve_file_path(image_path),
         artifact_path=request_dir / "gaussians.pt",
     )
     _log(
@@ -61,14 +88,14 @@ def reconstruct(image_path: FileData) -> FileData:
         seconds=round(time.perf_counter() - started, 3),
         bytes=artifact.stat().st_size,
     )
-    return FileData(path=str(artifact))
+    return {"url": _file_url(artifact)}
 
 
 @app.api(name="export_ply", queue=True, concurrency_limit=2)
-def export_ply(artifact: FileData) -> FileData:
-    """Filter and expose a PLY artifact."""
+def export_ply(artifact_url: str) -> dict:
+    """Filter one PLY artifact and return its public URL."""
     started = time.perf_counter()
-    internal = Path(artifact["path"])
+    internal = _resolve_file_path(artifact_url)
     scene_ply = export_filtered_gaussian_ply(
         artifact_path=internal,
         output_dir=internal.parent,
@@ -80,15 +107,16 @@ def export_ply(artifact: FileData) -> FileData:
         seconds=round(time.perf_counter() - started, 3),
         bytes=scene_ply.stat().st_size,
     )
-    return FileData(path=str(scene_ply))
+    return {"url": _file_url(scene_ply)}
 
 
 @app.api(name="export_viewer", queue=True, concurrency_limit=2)
-def export_viewer(scene_ply: FileData) -> FileData:
-    """Build the browser viewer and return its iframe-ready HTML."""
+def export_viewer(scene_ply_url: str) -> dict:
+    """Build the browser viewer and return its iframe-ready HTML URL."""
     started = time.perf_counter()
+    scene_ply_path = _resolve_file_path(scene_ply_url)
     exported = export_browser_viewer(
-        scene_ply=Path(scene_ply["path"]),
+        scene_ply=scene_ply_path,
         viewer_template=viewer_template,
     )
     _log(
@@ -96,17 +124,18 @@ def export_viewer(scene_ply: FileData) -> FileData:
         request=exported.viewer_html.parent.name,
         seconds=round(time.perf_counter() - started, 3),
         sog_bytes=exported.scene_sog.stat().st_size,
-        html_bytes=exported.viewer_html.stat().st_size,
+        viewer_html_bytes=exported.viewer_html.stat().st_size,
     )
-    return FileData(path=str(exported.viewer_html))
+    return {"url": _file_url(exported.viewer_html)}
 
 
 @app.api(name="export_html", queue=True, concurrency_limit=2)
-def export_html(viewer_html: FileData) -> FileData:
-    """Bundle a standalone HTML viewer for download."""
+def export_html(viewer_html_url: str) -> dict:
+    """Bundle a standalone HTML viewer and return its public URL."""
     started = time.perf_counter()
+    viewer_html_path = _resolve_file_path(viewer_html_url)
     standalone = export_standalone_viewer(
-        viewer_html=Path(viewer_html["path"]),
+        viewer_html=viewer_html_path,
         viewer_template=viewer_template,
     )
     _log(
@@ -115,13 +144,13 @@ def export_html(viewer_html: FileData) -> FileData:
         seconds=round(time.perf_counter() - started, 3),
         bytes=standalone.stat().st_size,
     )
-    return FileData(path=str(standalone))
+    return {"url": _file_url(standalone)}
 
 
 @app.api(name="viewer_html", queue=False)
-def viewer_html() -> FileData:
+def viewer_html() -> dict:
     """Serve the preloaded viewer template HTML for fast first paint."""
-    return FileData(path=str(viewer_template.viewer_html))
+    return {"url": _file_url(viewer_template.viewer_html)}
 
 
 INDEX_HTML = r"""<!doctype html>
@@ -703,18 +732,14 @@ INDEX_HTML = r"""<!doctype html>
         setViewerState("loading", { title: "Reconstructing scene", detail: "Running model inference", progress: 15 });
         const recon = await client.predict("/reconstruct", { image_path: handle_file(pendingFile) });
         const artifactUrl = recon.data[0].url;
-        const artifactResp = await fetch(artifactUrl);
-        const artifactBlob = await artifactResp.blob();
-        const artifactFile = new File([artifactBlob], "gaussians.pt");
 
         setViewerState("loading", { title: "Preparing PLY", detail: "Filtering Gaussians", progress: 45 });
-        const ply = await client.predict("/export_ply", { artifact: handle_file(artifactFile) });
+        const ply = await client.predict("/export_ply", { artifact_url: artifactUrl });
         const plyUrl = ply.data[0].url;
-        lastPlyUrl = plyUrl;
         setDownload(dlPly, plyUrl, "Download PLY — Ready");
 
         setViewerState("loading", { title: "Encoding viewer", detail: "Building WebGL scene", progress: 70 });
-        const view = await client.predict("/export_viewer", { scene_ply: handle_file(await (await fetch(plyUrl)).blob()) });
+        const view = await client.predict("/export_viewer", { scene_ply_url: plyUrl });
         const viewerUrl = view.data[0].url + "?v=" + Date.now();
         viewerFrame.src = viewerUrl;
         viewerFrame.onload = () => {
@@ -723,11 +748,8 @@ INDEX_HTML = r"""<!doctype html>
         };
 
         setViewerState("loading", { title: "Bundling HTML", detail: "Embedding assets for download", progress: 92 });
-        const html = await client.predict("/export_html", {
-          viewer_html: handle_file(await (await fetch(viewerUrl)).blob())
-        });
+        const html = await client.predict("/export_html", { viewer_html_url: viewerUrl.replace(/[?#].*/, "") });
         const htmlUrl = html.data[0].url;
-        lastHtmlUrl = htmlUrl;
         setDownload(dlHtml, htmlUrl, "Download HTML viewer — Ready");
 
         setViewerState("idle");