fix: recover invalid sabr sessions (#17)

## Summary
- recognize terminal SABR context recovery without changing selected
formats
- recreate one fresh playback session at the current position
- publish the engine as 0.1.20

## Verification
- `bun run check`
- `bun test`
- `bun run test:coverage`
- `bun run build`
- `bun run check:versions`
- `bun run check:docs`
- `bun run check:jsr`

Author: Priveetee

jsr.json

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typetype/mse",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "MSE playback engine for TypeType",
   "license": "MIT",
   "type": "module",

src/playback-window.ts

@@ -23,7 +23,9 @@ export type PlaybackWindowRequest = {
 };
 
 /** Recovery operation requested when the current playback session becomes terminal. */
-export type PlaybackWindowRecoveryAction = "retry_fresh_session_lower_video_itag";
+export type PlaybackWindowRecoveryAction =
+  | "retry_fresh_session"
+  | "retry_fresh_session_lower_video_itag";
 
 /** Parsed backend response containing media tracks or a retry instruction. */
 export type PlaybackWindow = {
@@ -70,7 +72,9 @@ function arrayField(value: object, key: string): unknown[] {
 
 function recoveryActionField(value: object): PlaybackWindowRecoveryAction | null {
   const result = field(value, "recoveryAction");
-  return result === "retry_fresh_session_lower_video_itag" ? result : null;
+  return result === "retry_fresh_session" || result === "retry_fresh_session_lower_video_itag"
+    ? result
+    : null;
 }
 
 function integerArrayField(value: object, key: string): number[] {

src/player-session-loader.ts

@@ -37,6 +37,9 @@ export async function loadPlayerSession(args: Args): Promise<LoadedSession> {
     return await loadSelectedSession(args, args.response, selection);
   } catch (error) {
     if (!(error instanceof PlaybackWindowRecoveryError)) throw error;
+    if (error.recoveryAction === "retry_fresh_session") {
+      return recoverWithFreshSession(args, selection);
+    }
     return recoverWithFreshSessions(args, selection, error.retryVideoItags);
   }
 }
@@ -109,6 +112,24 @@ async function recoverWithFreshSessions(
   throw new Error("Playback window recovery failed");
 }
 
+async function recoverWithFreshSession(
+  args: Args,
+  selection: TrackSelection,
+): Promise<LoadedSession> {
+  const response = await args.deps.playback.create(
+    {
+      videoId: args.config.videoId,
+      videoItag: selection.videoItag,
+      audioItag: selection.audioItag,
+      audioTrackId: selection.audioTrackId,
+      startTimeMs: args.startTimeMs,
+      audioOnly: args.config.audioOnly === true,
+    },
+    args.signal,
+  );
+  return loadSelectedSession(args, response, selection);
+}
+
 function isAbortError(error: unknown): boolean {
   return error instanceof DOMException && error.name === "AbortError";
 }

src/session-loader.ts

@@ -192,7 +192,7 @@ function retryDelay(
 
 function handleWindow(window: Awaited<ReturnType<PlaybackClient["segments"]>>) {
   if (!window.terminalError) return window;
-  if (window.recoveryAction && window.retryVideoItags.length > 0) {
+  if (window.recoveryAction) {
     throw new PlaybackWindowRecoveryError(
       window.terminalError,
       window.recoveryAction,

tests/playback-window.test.ts

@@ -60,6 +60,22 @@ test("parses playback window recovery hints", () => {
   expect(window.retryVideoItags).toEqual([136, 135, 134]);
 });
 
+test("parses fresh session recovery without changing formats", () => {
+  const window = parsePlaybackWindow(
+    {
+      sessionId: "session",
+      generation: 1,
+      ready: false,
+      terminalError: "Expected UMP response, got content type: text/plain",
+      recoveryAction: "retry_fresh_session",
+      retryVideoItags: [],
+    },
+    "https://beta.typetype.video/api/sabr/playback/session/window",
+  );
+  expect(window.recoveryAction).toBe("retry_fresh_session");
+  expect(window.retryVideoItags).toEqual([]);
+});
+
 test("parses audio-only playback windows", () => {
   const window = parsePlaybackWindow(
     {

tests/player-session-loader.test.ts

@@ -160,3 +160,74 @@ test("recovers terminal seek windows with a fresh lower video itag session", asy
   expect(positionRequests[0]).toEqual([]);
   expect(filledWindows).toEqual([[120_000, 59_000, 90_000]]);
 });
+
+test("recovers invalid sabr context with a fresh session using the same formats", async () => {
+  const created: number[] = [];
+  const session = await loadPlayerSession({
+    deps: {
+      playback: {
+        create: async (request) => {
+          created.push(request.videoItag);
+          return response("fresh-session", request.videoId);
+        },
+        position: async (sessionId, request) => window(sessionId, request.generation, false),
+        prefetch: async (sessionId, request) =>
+          sessionId === "stale-session"
+            ? {
+                ...window(sessionId, request.generation, false),
+                terminalError: "Expected UMP response, got content type: text/plain",
+                recoveryAction: "retry_fresh_session",
+              }
+            : { ...window(sessionId, request.generation, true), manifest },
+        segments: async (sessionId, request) => ({
+          ...window(sessionId, request.generation, true),
+          manifest,
+        }),
+      },
+      media: { attach: async () => undefined, bufferedRanges: () => [] },
+      scheduler: {
+        reset: () => undefined,
+        appendInit: async () => undefined,
+        fill: async () => undefined,
+      },
+      policy: {
+        bufferGoalMs: 30_000,
+        backBufferMs: 30_000,
+        pollIntervalMs: 500,
+        manifestRefreshMs: 8_000,
+        manifestPollLimit: 2,
+        segmentPollLimit: 2,
+      },
+    },
+    config: {
+      endpoint: "https://beta.typetype.video/api",
+      videoId: "Vj6ReOur1Kk",
+      videoItag: 137,
+      audioItag: 140,
+      audioTrackId: "fr-FR.4",
+    },
+    video: { currentTime: 399.383 },
+    response: response("stale-session", "Vj6ReOur1Kk"),
+    current: null,
+    quality: undefined,
+    startTimeMs: 399_383,
+    signal: new AbortController().signal,
+  });
+
+  expect(created).toEqual([137]);
+  expect(session.response.sessionId).toBe("fresh-session");
+  expect(session.videoItag).toBe(137);
+});
+
+function window(sessionId: string, generation: number | null, ready: boolean): PlaybackWindow {
+  return {
+    sessionId,
+    generation,
+    ready,
+    retryAfterMs: null,
+    terminalError: null,
+    recoveryAction: null,
+    retryVideoItags: [],
+    manifest: null,
+  };
+}