Files: play video and audio in the viewer, as the file is; reads answer Range requests

The viewer hands a video or audio file to the browser untouched — container, codec and
all — and the browser plays what it can; when it can't, the viewer says so and offers the
download. What the server adds is the part a player needs: /api/files/read now goes
through http.ServeContent for a real file of known size, so Range requests (seeking) and
HEAD work, and a download can resume. The root backend's helper takes an offset for that,
and a Seeker opens the backend once, at the range asked for, instead of streaming from
the top. Audio files are a preview kind too: their cover art is the thumbnail.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/api/server.go

@@ -1928,16 +1928,6 @@ func (s *Server) filesRead(w http.ResponseWriter, r *http.Request) {
 		jsonErr(w, 413, "file too large")
 		return
 	}
-	f, err := fsys.Open(r.Context(), p)
-	if err != nil {
-		fsErr(w, err)
-		return
-	}
-	defer f.Close()
-	var body io.Reader = f
-	if mx > 0 { // stat can lie (size 0 on /proc); the cap must hold on the bytes actually sent
-		body = io.LimitReader(f, mx+1)
-	}
 	name := filepath.Base(p)
 	ct := mime.TypeByExtension(filepath.Ext(name))
 	if ct == "" {
@@ -1956,7 +1946,28 @@ func (s *Server) filesRead(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Disposition", "inline; filename*=UTF-8''"+url.PathEscape(name))
 	}
 	if in.Size > 0 && mx == 0 {
-		w.Header().Set("Content-Length", strconv.FormatInt(in.Size, 10))
+		// A real file of known size goes through net/http, which speaks Range: a video player
+		// can seek and a download can resume. /proc files say size 0 and take the plain path.
+		rs := files.NewSeeker(r.Context(), fsys, p, in.Size)
+		defer rs.Close()
+		if _, local := fsys.(files.Local); local { // cheap here, and turns "can't open" into a status rather than a cut-off body
+			if err := rs.Check(); err != nil {
+				fsErr(w, err)
+				return
+			}
+		}
+		http.ServeContent(w, r, name, time.UnixMilli(in.Mtime), rs)
+		return
+	}
+	f, err := fsys.Open(r.Context(), p)
+	if err != nil {
+		fsErr(w, err)
+		return
+	}
+	defer f.Close()
+	var body io.Reader = f
+	if mx > 0 { // stat can lie (size 0 on /proc); the cap must hold on the bytes actually sent
+		body = io.LimitReader(f, mx+1)
 	}
 	_, _ = io.Copy(w, body)
 }