chore: prepare player 0.1.60 for TypeType 1.8.1

biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.5.10/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.12/schema.json",
   "formatter": {
     "enabled": true,
     "indentStyle": "space",

jsr.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@typetype/mse",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "exports": "./src/index.ts",
   "publish": {
     "include": ["LICENSE", "README.md", "src/**/*.ts"]

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typetype/mse",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "MSE playback engine for TypeType",
   "license": "MIT",
   "type": "module",
@@ -40,7 +40,7 @@
     "publish:jsr": "deno publish"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.5.10",
+    "@biomejs/biome": "^2.5.12",
     "typescript": "~7.0.2"
   },
   "publishConfig": {

src/media-buffer.ts

@@ -1,14 +1,41 @@
 const RANGE_TOLERANCE_SECONDS = 0.05;
+const TRACK_RANGE_TOLERANCE_MS = 50;
 const MIN_SEEK_BUFFER_MS = 250;
 const RANGE_ENTRY_OFFSET_SECONDS = 0.001;
 
+export type BufferedTrackRange = {
+  kind: "audio" | "video";
+  startMs: number;
+  endMs: number;
+};
+
 export function bufferedEndAtCurrentTime(
   video: Pick<HTMLVideoElement, "buffered" | "currentTime">,
 ): number {
   const range = bufferedRangeAt(video.buffered, video.currentTime);
   return range ? Math.round(range.end * 1000) : 0;
 }
 
+export function bufferedEndAtCurrentTrackRanges(
+  ranges: readonly BufferedTrackRange[],
+  currentMs: number,
+  hasVideo: boolean,
+): number {
+  const kinds: BufferedTrackRange["kind"][] = hasVideo ? ["audio", "video"] : ["audio"];
+  const ends = kinds.map((kind) => {
+    const range = ranges.find(
+      (candidate) =>
+        candidate.kind === kind &&
+        candidate.startMs <= currentMs + TRACK_RANGE_TOLERANCE_MS &&
+        candidate.endMs > currentMs - TRACK_RANGE_TOLERANCE_MS,
+    );
+    return range?.endMs ?? null;
+  });
+  if (ends.some((endMs) => endMs === null)) return 0;
+  const completeEnds = ends.filter((endMs): endMs is number => endMs !== null);
+  return Math.min(...completeEnds);
+}
+
 export function seekWithinBufferedMedia(
   video: Pick<HTMLVideoElement, "buffered" | "currentTime">,
   targetMs: number,

src/player-deps.ts

@@ -1,6 +1,7 @@
 import { type BufferPolicy, resolveBufferPolicy } from "./buffer-policy";
 import type { EventEmitter } from "./event-emitter";
 import { HttpClient } from "./http-client";
+import { bufferedEndAtCurrentTrackRanges } from "./media-buffer";
 import { MediaElementObserver } from "./media-element-observer";
 import { MediaSourceController } from "./media-source-controller";
 import { PlaybackClient } from "./playback-client";
@@ -53,6 +54,17 @@ export function createPlayerDeps(args: Args): PlayerDeps {
   });
   const media = new MediaSourceController(args.video);
   const scheduler = new SegmentScheduler(http, media, args.emitter, policy.segmentPollLimit);
+  const currentBufferedEndMs = () => {
+    const elementBufferedEndMs = bufferedEndMs(args.video);
+    if (elementBufferedEndMs > 0) return elementBufferedEndMs;
+    const session = args.session();
+    if (!session) return elementBufferedEndMs;
+    return bufferedEndAtCurrentTrackRanges(
+      media.bufferedRanges(),
+      Math.max(0, Math.round(args.video.currentTime * 1000)),
+      session.manifest.video !== null,
+    );
+  };
   const loop = new PlaybackLoop({
     video: args.video,
     playback,
@@ -63,7 +75,7 @@ export function createPlayerDeps(args: Args): PlayerDeps {
     playbackRate,
     session: args.session,
     signal: args.signal,
-    bufferedEndMs: () => bufferedEndMs(args.video),
+    bufferedEndMs: currentBufferedEndMs,
     error: args.loopError,
   });
   const destroy = () => {

src/segment-scheduler.ts

@@ -1,26 +1,26 @@
 import type { EventEmitter } from "./event-emitter";
 import type { HttpClient } from "./http-client";
 import type { ManifestSegment, PlaybackManifest } from "./manifest";
-import type { MediaSourceController } from "./media-source-controller";
+import type { MediaBufferedRange, MediaSourceController } from "./media-source-controller";
 import { fetchSegmentBytes } from "./segment-fetcher";
 import type { TrackKind } from "./types";
 
+const BUFFERED_RANGE_TOLERANCE_MS = 50;
+
 export class SegmentScheduler {
   private readonly appended = new Set<string>();
-  private readonly appendedEndMs = new Map<TrackKind, number>();
   private revision = 0;
 
   constructor(
     private readonly http: HttpClient,
-    private readonly media: MediaSourceController,
+    private readonly media: Pick<MediaSourceController, "append" | "bufferedRanges">,
     private readonly emitter: EventEmitter,
     private readonly pollLimit: number,
   ) {}
 
   reset(): void {
     this.revision += 1;
     this.appended.clear();
-    this.appendedEndMs.clear();
   }
 
   async appendInit(manifest: PlaybackManifest, signal?: AbortSignal): Promise<void> {
@@ -65,8 +65,7 @@ export class SegmentScheduler {
       .sort((left, right) => left.startMs - right.startMs);
     for (const segment of candidates) {
       const segmentEndMs = segment.startMs + segment.durationMs;
-      const appendedEndMs = this.appendedEndMs.get(kind);
-      if (appendedEndMs !== undefined && segmentEndMs <= appendedEndMs) continue;
+      if (this.isBuffered(kind, segment.startMs, segmentEndMs)) continue;
       await this.appendUrl(
         kind,
         segment.url,
@@ -75,7 +74,6 @@ export class SegmentScheduler {
         revision,
         signal,
       );
-      this.appendedEndMs.set(kind, Math.max(appendedEndMs ?? 0, segmentEndMs));
     }
   }
 
@@ -89,7 +87,10 @@ export class SegmentScheduler {
   ): Promise<void> {
     this.ensureActive(revision, signal);
     const key = `${kind}:${url}`;
-    if (this.appended.has(key)) return;
+    if (this.appended.has(key)) {
+      if (durationMs <= 0 || this.isBuffered(kind, startMs, startMs + durationMs)) return;
+      this.appended.delete(key);
+    }
     const bytes = await fetchSegmentBytes(this.http, url, this.pollLimit, signal);
     this.ensureActive(revision, signal);
     await this.media.append(kind, bytes);
@@ -98,9 +99,27 @@ export class SegmentScheduler {
     this.emitter.emit({ type: "segment", kind, url, startMs, durationMs });
   }
 
+  private isBuffered(kind: TrackKind, startMs: number, endMs: number): boolean {
+    if (endMs <= startMs) return false;
+    return this.media.bufferedRanges().some((range) => coversSegment(range, kind, startMs, endMs));
+  }
+
   private ensureActive(revision: number, signal?: AbortSignal): void {
     if (revision !== this.revision || signal?.aborted) {
       throw new DOMException("Operation aborted", "AbortError");
     }
   }
 }
+
+function coversSegment(
+  range: MediaBufferedRange,
+  kind: TrackKind,
+  startMs: number,
+  endMs: number,
+): boolean {
+  return (
+    range.kind === kind &&
+    range.startMs <= startMs + BUFFERED_RANGE_TOLERANCE_MS &&
+    range.endMs >= endMs - BUFFERED_RANGE_TOLERANCE_MS
+  );
+}

tests/media-buffer.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from "bun:test";
 import {
   alignPlayheadToBufferedRange,
   bufferedEndAtCurrentTime,
+  bufferedEndAtCurrentTrackRanges,
   canUseBufferedMediaSeek,
   seekWithinBufferedMedia,
 } from "../src/media-buffer";
@@ -34,6 +35,17 @@ test("does not report media beyond a gap as buffered at the playhead", () => {
   ).toBe(0);
 });
 
+test("uses the shorter source-buffer track when the media element range is empty", () => {
+  const ranges = [
+    { kind: "audio" as const, startMs: 0, endMs: 20_000 },
+    { kind: "video" as const, startMs: 500, endMs: 18_000 },
+  ];
+
+  expect(bufferedEndAtCurrentTrackRanges(ranges, 1_000, true)).toBe(18_000);
+  expect(bufferedEndAtCurrentTrackRanges(ranges, 19_000, true)).toBe(0);
+  expect(bufferedEndAtCurrentTrackRanges(ranges, 1_000, false)).toBe(20_000);
+});
+
 test("seeks locally only when the target has enough buffered media", () => {
   const video = media(
     [

tests/segment-scheduler.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from "bun:test";
 import type { EventEmitter } from "../src/event-emitter";
 import type { HttpClient } from "../src/http-client";
 import type { PlaybackManifest } from "../src/manifest";
-import type { MediaSourceController } from "../src/media-source-controller";
+import type { MediaBufferedRange, MediaSourceController } from "../src/media-source-controller";
 import { SegmentScheduler } from "../src/segment-scheduler";
 
 const track = {
@@ -23,22 +23,36 @@ function manifest(segments: PlaybackManifest["audio"]["segments"]): PlaybackMani
 
 test("never appends a late segment behind the buffered track edge", async () => {
   const appended: string[] = [];
+  const buffered: MediaBufferedRange[] = [];
   let requestedUrl = "";
   const http = {
     response: async (url: string) => {
       requestedUrl = url;
       return new Response(new Uint8Array([1]));
     },
   } as HttpClient;
-  const media = {
-    append: async () => appended.push(requestedUrl),
-  } as MediaSourceController;
-  const scheduler = new SegmentScheduler(http, media, { emit: () => undefined } as EventEmitter, 1);
   const segment40 = { url: "/40", startMs: 389_398, durationMs: 9_985 };
   const segment41 = { url: "/41", startMs: 399_383, durationMs: 9_985 };
   const segment42 = { url: "/42", startMs: 409_367, durationMs: 9_985 };
   const segment43 = { url: "/43", startMs: 419_352, durationMs: 9_985 };
-
+  const segmentsByUrl = new Map(
+    [segment40, segment41, segment42, segment43].map((segment) => [segment.url, segment]),
+  );
+  const media = {
+    append: async (kind: "audio" | "video") => {
+      appended.push(requestedUrl);
+      const segment = segmentsByUrl.get(requestedUrl);
+      if (segment) {
+        buffered.push({
+          kind,
+          startMs: segment.startMs,
+          endMs: segment.startMs + segment.durationMs,
+        });
+      }
+    },
+    bufferedRanges: () => buffered,
+  } as MediaSourceController;
+  const scheduler = new SegmentScheduler(http, media, { emit: () => undefined } as EventEmitter, 1);
   await scheduler.fill(manifest([segment43, segment41, segment42]), 401_200, 430_000);
   await scheduler.fill(manifest([segment40, segment41, segment42, segment43]), 399_383, 430_000);
 
@@ -56,8 +70,14 @@ test("appends a self-initializing live segment only once", async () => {
     },
   } as HttpClient;
   const appended: string[] = [];
+  const buffered: MediaBufferedRange[] = [];
   const media = {
-    append: async () => appended.push(requestedUrl),
+    append: async (kind: "audio" | "video") => {
+      appended.push(requestedUrl);
+      const startMs = requestedUrl === "/40" ? 390_000 : 400_000;
+      buffered.push({ kind, startMs, endMs: startMs + 10_000 });
+    },
+    bufferedRanges: () => buffered,
   } as MediaSourceController;
   const scheduler = new SegmentScheduler(http, media, { emit: () => undefined } as EventEmitter, 1);
   const liveManifest = manifest([
@@ -84,6 +104,7 @@ test("rejects fetched bytes from a superseded scheduler revision", async () => {
     append: async () => {
       appends += 1;
     },
+    bufferedRanges: () => [],
   } as MediaSourceController;
   const scheduler = new SegmentScheduler(http, media, { emit: () => undefined } as EventEmitter, 1);
   const fill = scheduler.fill(
@@ -99,3 +120,28 @@ test("rejects fetched bytes from a superseded scheduler revision", async () => {
   await expect(fill).rejects.toHaveProperty("name", "AbortError");
   expect(appends).toBe(0);
 });
+
+test("re-fetches a segment after its SourceBuffer range was evicted", async () => {
+  const requested: string[] = [];
+  let buffered: MediaBufferedRange[] = [];
+  const http = {
+    response: async (url: string) => {
+      requested.push(url);
+      return new Response(new Uint8Array([1]));
+    },
+  } as HttpClient;
+  const media = {
+    append: async () => {
+      buffered = [{ kind: "audio", startMs: 0, endMs: 10_000 }];
+    },
+    bufferedRanges: () => buffered,
+  } as MediaSourceController;
+  const scheduler = new SegmentScheduler(http, media, { emit: () => undefined } as EventEmitter, 1);
+  const segment = { url: "/segment", startMs: 0, durationMs: 10_000 };
+
+  await scheduler.fill(manifest([segment]), 0, 10_000);
+  buffered = [];
+  await scheduler.fill(manifest([segment]), 0, 10_000);
+
+  expect(requested).toEqual(["/segment", "/segment"]);
+});