截尾帧却拿到首帧：媒体代理为什么必须支持 Range

type FrameKind = 'current' | 'first' | 'last'

function waitFor(video: HTMLVideoElement, event: 'loadeddata' | 'seeked') {
  return new Promise<void>((resolve, reject) => {
    const done = () => { cleanup(); resolve() }
    const fail = () => { cleanup(); reject(new Error('视频加载失败')) }
    const cleanup = () => {
      video.removeEventListener(event, done)
      video.removeEventListener('error', fail)
    }
    video.addEventListener(event, done)
    video.addEventListener('error', fail)
  })
}

export async function captureFrame(src: string, kind: FrameKind, currentTime: number): Promise<Blob> {
  const video = document.createElement('video')
  video.crossOrigin = 'anonymous' // 否则 canvas 被污染，toBlob 会抛 SecurityError
  video.muted = true
  video.preload = 'auto'
  try {
    const loaded = waitFor(video, 'loadeddata')
    video.src = src
    await loaded

    // 直接 seek 到 duration 经常拿到黑帧，尾帧往前退一点点
    const target =
      kind === 'first' ? 0 : kind === 'last' ? Math.max(0, video.duration - 0.05) : currentTime
    if (target !== video.currentTime) {
      const seeked = waitFor(video, 'seeked')
      video.currentTime = target
      await seeked
    }

    const canvas = document.createElement('canvas')
    canvas.width = video.videoWidth
    canvas.height = video.videoHeight
    canvas.getContext('2d')!.drawImage(video, 0, 0)
    return await new Promise((resolve, reject) =>
      canvas.toBlob((b) => (b ? resolve(b) : reject(new Error('截帧失败'))), 'image/png')
    )
  } finally {
    video.removeAttribute('src')
    video.load() // 释放连接和解码器
  }
}

// 只保留单段 Range（bytes=a-b），多段 Range 直接丢弃，按完整资源返回
func singleRange(h string) string {
	h = strings.TrimSpace(h)
	if !strings.HasPrefix(h, "bytes=") || strings.Contains(h, ",") {
		return ""
	}
	return h
}

// "bytes 0-1023/52428800" -> 52428800
func totalFromContentRange(h string) int64 {
	i := strings.LastIndex(h, "/")
	if i < 0 {
		return -1
	}
	n, err := strconv.ParseInt(strings.TrimSpace(h[i+1:]), 10, 64)
	if err != nil {
		return -1
	}
	return n
}

func proxyMedia(w http.ResponseWriter, r *http.Request, upstreamURL string, maxBytes int64) {
	req, _ := http.NewRequestWithContext(r.Context(), r.Method, upstreamURL, nil)
	if rg := singleRange(r.Header.Get("Range")); rg != "" {
		req.Header.Set("Range", rg)
	}
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		http.Error(w, "upstream error", http.StatusBadGateway)
		return
	}
	defer resp.Body.Close()

	partial := resp.StatusCode == http.StatusPartialContent
	total := resp.ContentLength
	if partial {
		total = totalFromContentRange(resp.Header.Get("Content-Range"))
	}
	// 大小上限要按"完整资源大小"判断，而不是这一段的大小
	if total > maxBytes {
		http.Error(w, "media too large", http.StatusRequestEntityTooLarge)
		return
	}

	w.Header().Set("Content-Type", resp.Header.Get("Content-Type"))
	if partial || strings.EqualFold(resp.Header.Get("Accept-Ranges"), "bytes") {
		w.Header().Set("Accept-Ranges", "bytes")
	}
	if resp.ContentLength >= 0 {
		w.Header().Set("Content-Length", strconv.FormatInt(resp.ContentLength, 10))
	}
	status := http.StatusOK
	if partial {
		w.Header().Set("Content-Range", resp.Header.Get("Content-Range"))
		status = http.StatusPartialContent
	}
	w.WriteHeader(status)
	if r.Method != http.MethodHead {
		_, _ = io.Copy(w, io.LimitReader(resp.Body, maxBytes)) // 流式转发，不再整段进内存
	}
}