@hyperframes/studio 0.8.210 → 0.8.212

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -106,6 +106,313 @@ describe("mediaUrlSourceOptions", () => {
106
106
  }
107
107
  });
108
108
 
109
+ it("fails a read stalled mid-body once its reader is disposed and its reads cancelled", async () => {
110
+ // Like fetch, the stub ends its body when the request's signal aborts, and not before.
111
+ vi.stubGlobal(
112
+ "fetch",
113
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
114
+ let sent = false;
115
+ const body = new ReadableStream<Uint8Array>({
116
+ pull(controller) {
117
+ if (!sent) {
118
+ sent = true;
119
+ return controller.enqueue(new Uint8Array(16));
120
+ }
121
+ return new Promise<void>((resolve) => {
122
+ const end = () => {
123
+ controller.error(init?.signal?.reason);
124
+ resolve();
125
+ };
126
+ init?.signal?.addEventListener("abort", end, { once: true });
127
+ });
128
+ },
129
+ });
130
+ const headers = { "Content-Range": "bytes 0-999999/1000000", "Content-Length": "1000000" };
131
+ return new Response(body, { status: 206, headers });
132
+ }),
133
+ );
134
+ const mb = await import("mediabunny");
135
+ const runnerListeners = process.listeners("unhandledRejection");
136
+ process.removeAllListeners("unhandledRejection");
137
+ process.on("unhandledRejection", () => {});
138
+ try {
139
+ const options = mediaUrlSourceOptions("thumbnail");
140
+ const input = new mb.Input({
141
+ source: new mb.UrlSource(URL_WITH_PATH, options),
142
+ formats: mb.ALL_FORMATS,
143
+ });
144
+ let settled = false;
145
+ const read = input.getDurationFromMetadata().finally(() => (settled = true));
146
+ read.catch(() => {});
147
+ await new Promise((resolve) => setTimeout(resolve, 20));
148
+ expect(settled).toBe(false);
149
+
150
+ input.dispose();
151
+ options.cancelReads();
152
+ await expect(read).rejects.toBeDefined();
153
+ // The cancelled read-ahead's own rejection lands a turn later; keep it out of the next test.
154
+ await new Promise(setImmediate);
155
+ await new Promise(setImmediate);
156
+ } finally {
157
+ process.removeAllListeners("unhandledRejection");
158
+ for (const listener of runnerListeners) process.on("unhandledRejection", listener);
159
+ }
160
+ });
161
+
162
+ // Like fetch, a stub whose waits end when the request's signal aborts, and not before.
163
+ const endsOnAbort = (signal: AbortSignal | null | undefined) =>
164
+ new Promise<never>((_, reject) =>
165
+ signal?.addEventListener("abort", () => reject(signal.reason), { once: true }),
166
+ );
167
+
168
+ it("gives up on a response that sends no bytes, as a stall, inside the load timeout", async () => {
169
+ vi.useFakeTimers();
170
+ const requests: (string | null)[] = [];
171
+ vi.stubGlobal(
172
+ "fetch",
173
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
174
+ requests.push(new Headers(init?.headers).get("Range"));
175
+ const body = new ReadableStream<Uint8Array>({ pull: () => endsOnAbort(init?.signal) });
176
+ const headers = { "Content-Range": "bytes 0-999999/1000000", "Content-Length": "1000000" };
177
+ return new Response(body, { status: 206, headers });
178
+ }),
179
+ );
180
+ vi.spyOn(console, "error").mockImplementation(() => {});
181
+ const mb = await import("mediabunny");
182
+ const runnerListeners = process.listeners("unhandledRejection");
183
+ process.removeAllListeners("unhandledRejection");
184
+ process.on("unhandledRejection", () => {});
185
+ try {
186
+ const input = new mb.Input({
187
+ source: new mb.UrlSource(URL_WITH_PATH, mediaUrlSourceOptions("thumbnail")),
188
+ formats: mb.ALL_FORMATS,
189
+ });
190
+ let outcome: unknown = "pending";
191
+ void input.getDurationFromMetadata().then(
192
+ () => (outcome = "resolved"),
193
+ (error: unknown) => (outcome = error),
194
+ );
195
+ // Three silent waits of 8 s, with mediabunny's 0.5 s and 1 s retry delays between them.
196
+ await vi.advanceTimersByTimeAsync(25_400);
197
+ expect(outcome).toBe("pending");
198
+ await vi.advanceTimersByTimeAsync(200);
199
+ expect(outcome).toMatchObject({
200
+ name: "MediaFetchError",
201
+ message: "thumbnail range fetch failed: network stalled after 2 retries",
202
+ });
203
+ expect(requests).toHaveLength(3);
204
+ input.dispose();
205
+ } finally {
206
+ vi.useRealTimers();
207
+ // mediabunny rethrows the failed read-ahead a turn later; keep it out of the next test.
208
+ await new Promise(setImmediate);
209
+ await new Promise(setImmediate);
210
+ process.removeAllListeners("unhandledRejection");
211
+ for (const listener of runnerListeners) process.on("unhandledRejection", listener);
212
+ }
213
+ });
214
+
215
+ it("never cuts off a request still waiting for its answer, however long it queues", async () => {
216
+ // Chrome queues a request for one of six connections per host, which streaming previews may hold.
217
+ vi.useFakeTimers();
218
+ vi.stubGlobal(
219
+ "fetch",
220
+ vi.fn(
221
+ () =>
222
+ new Promise<Response>((resolve) =>
223
+ setTimeout(() => resolve(new Response("", { status: 206 })), 20_000),
224
+ ),
225
+ ),
226
+ );
227
+ try {
228
+ const answer = mediaUrlSourceOptions("thumbnail").fetchFn(URL_WITH_PATH, {
229
+ headers: { Range: "bytes=0-" },
230
+ });
231
+ await vi.advanceTimersByTimeAsync(20_000);
232
+ expect((await answer).status).toBe(206);
233
+ } finally {
234
+ vi.useRealTimers();
235
+ }
236
+ });
237
+
238
+ it("fails a body that sends nothing for 8 s as stalled, and aborts its fetch", async () => {
239
+ vi.useFakeTimers();
240
+ let sentSignal: AbortSignal | undefined;
241
+ vi.stubGlobal(
242
+ "fetch",
243
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
244
+ sentSignal = init?.signal ?? undefined;
245
+ // Deaf to its signal: only the watchdog can end this wait.
246
+ const body = new ReadableStream<Uint8Array>({ pull: () => new Promise<void>(() => {}) });
247
+ return new Response(body, { status: 206 });
248
+ }),
249
+ );
250
+ try {
251
+ const response = await mediaUrlSourceOptions("thumbnail").fetchFn(URL_WITH_PATH, {
252
+ headers: { Range: "bytes=4096-" },
253
+ });
254
+ const read = response
255
+ .body!.getReader()
256
+ .read()
257
+ .catch((e: unknown) => e);
258
+ await vi.advanceTimersByTimeAsync(8_000);
259
+ expect(await read).toMatchObject({ name: "MediaFetchError", code: "stalled", start: 4096 });
260
+ expect(sentSignal?.aborted).toBe(true);
261
+ } finally {
262
+ vi.useRealTimers();
263
+ }
264
+ });
265
+
266
+ it("never times out a probe's body, however slow", async () => {
267
+ vi.useFakeTimers();
268
+ vi.stubGlobal(
269
+ "fetch",
270
+ vi.fn(async () => {
271
+ const body = new ReadableStream<Uint8Array>({
272
+ pull: (controller) =>
273
+ new Promise<void>((resolve) =>
274
+ setTimeout(() => {
275
+ controller.enqueue(new Uint8Array(8));
276
+ controller.close();
277
+ resolve();
278
+ }, 20_000),
279
+ ),
280
+ });
281
+ return new Response(body, { status: 206 });
282
+ }),
283
+ );
284
+ try {
285
+ const response = await mediaUrlSourceOptions("probe").fetchFn(URL_WITH_PATH, {
286
+ headers: { Range: "bytes=0-" },
287
+ });
288
+ const read = response.arrayBuffer();
289
+ await vi.advanceTimersByTimeAsync(20_000);
290
+ expect((await read).byteLength).toBe(8);
291
+ } finally {
292
+ vi.useRealTimers();
293
+ }
294
+ });
295
+
296
+ it("starts every request made after its reader's reads were cancelled already aborted", async () => {
297
+ const seen: AbortSignal[] = [];
298
+ vi.stubGlobal(
299
+ "fetch",
300
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
301
+ if (init?.signal) seen.push(init.signal);
302
+ return new Response("", { status: 206 });
303
+ }),
304
+ );
305
+ const { fetchFn, cancelReads } = mediaUrlSourceOptions("thumbnail");
306
+ cancelReads();
307
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=0-" } }).catch(() => {});
308
+ await Promise.resolve();
309
+ expect(seen[0]?.aborted).toBe(true);
310
+ });
311
+
312
+ it("unlinks every request from mediabunny's signal however it ends", async () => {
313
+ const answers: (() => Promise<Response>)[] = [
314
+ async () => new Response(new Uint8Array(4), { status: 206 }),
315
+ async () => Promise.reject(new TypeError("Failed to fetch")),
316
+ async () => new Response("", { status: 503 }),
317
+ async () => new Response(null, { status: 206 }),
318
+ async () =>
319
+ new Response(
320
+ new ReadableStream({ pull: (controller) => controller.error(new TypeError("network")) }),
321
+ { status: 206 },
322
+ ),
323
+ async () =>
324
+ new Response(
325
+ new ReadableStream({ pull: (controller) => controller.enqueue(new Uint8Array(4)) }),
326
+ { status: 206 },
327
+ ),
328
+ ];
329
+ let call = 0;
330
+ vi.stubGlobal(
331
+ "fetch",
332
+ vi.fn(() => answers[call++]!()),
333
+ );
334
+ const { fetchFn } = mediaUrlSourceOptions("thumbnail");
335
+ let added = 0;
336
+ let removed = 0;
337
+ for (const exit of ["ok", "rejected", "503", "no body", "body error", "cancel"]) {
338
+ const signal = new AbortController().signal;
339
+ const add = signal.addEventListener.bind(signal);
340
+ const remove = signal.removeEventListener.bind(signal);
341
+ signal.addEventListener = (...args: Parameters<typeof add>) => (added++, add(...args));
342
+ signal.removeEventListener = (...args: Parameters<typeof remove>) => (
343
+ removed++, remove(...args)
344
+ );
345
+ const response = await fetchFn(URL_WITH_PATH, {
346
+ headers: { Range: "bytes=0-" },
347
+ signal,
348
+ }).catch(() => null);
349
+ const reader = response?.body?.getReader();
350
+ if (exit === "cancel") {
351
+ await reader!.read();
352
+ await reader!.cancel();
353
+ } else if (reader) {
354
+ await (async () => {
355
+ for (;;) if ((await reader.read()).done) return;
356
+ })().catch(() => {});
357
+ }
358
+ }
359
+
360
+ expect({ added, removed }).toEqual({ added: 6, removed: 6 });
361
+ });
362
+
363
+ it("never cuts off a slow response that keeps sending", async () => {
364
+ vi.useFakeTimers();
365
+ vi.stubGlobal(
366
+ "fetch",
367
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
368
+ let chunks = 0;
369
+ const body = new ReadableStream<Uint8Array>({
370
+ // Like fetch, the body fails if the request is aborted.
371
+ start: (controller) =>
372
+ init?.signal?.addEventListener("abort", () => controller.error(init.signal?.reason)),
373
+ pull: (controller) =>
374
+ new Promise<void>((resolve) =>
375
+ setTimeout(() => {
376
+ if (++chunks > 10) controller.close();
377
+ else controller.enqueue(new Uint8Array(1024));
378
+ resolve();
379
+ }, 2_000),
380
+ ),
381
+ });
382
+ return new Response(body, { status: 206 });
383
+ }),
384
+ );
385
+ try {
386
+ const response = await mediaUrlSourceOptions("thumbnail").fetchFn(URL_WITH_PATH, {
387
+ headers: { Range: "bytes=0-" },
388
+ });
389
+ const read = response.arrayBuffer();
390
+ await vi.advanceTimersByTimeAsync(24_000);
391
+ expect((await read).byteLength).toBe(10 * 1024);
392
+ } finally {
393
+ vi.useRealTimers();
394
+ }
395
+ });
396
+
397
+ it("aborts a request when mediabunny aborts its own signal", async () => {
398
+ const seen: AbortSignal[] = [];
399
+ vi.stubGlobal(
400
+ "fetch",
401
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
402
+ if (init?.signal) seen.push(init.signal);
403
+ return new Response("", { status: 206 });
404
+ }),
405
+ );
406
+ const stop = new AbortController();
407
+ await mediaUrlSourceOptions("thumbnail").fetchFn(URL_WITH_PATH, {
408
+ headers: { Range: "bytes=0-" },
409
+ signal: stop.signal,
410
+ });
411
+ expect(seen[0]?.aborted).toBe(false);
412
+ stop.abort();
413
+ expect(seen[0]?.aborted).toBe(true);
414
+ });
415
+
109
416
  it("counts mid-stream read failures, which always arrive as attempt 1", () => {
110
417
  const { getRetryDelay } = mediaUrlSourceOptions("thumbnail");
111
418
  const readError = new TypeError("network error");
@@ -113,6 +420,190 @@ describe("mediaUrlSourceOptions", () => {
113
420
  expect([1, 1, 1].map((attempt) => getRetryDelay(attempt, readError))).toEqual([0.5, 1, null]);
114
421
  });
115
422
 
423
+ // What mediabunny does with a body that breaks: feed the failure to getRetryDelay, then ask again.
424
+ async function readUntilBroken(
425
+ fetchFn: ReturnType<typeof mediaUrlSourceOptions>["fetchFn"],
426
+ range: string,
427
+ ) {
428
+ const reader = (await fetchFn(URL_WITH_PATH, { headers: { Range: range } })).body!.getReader();
429
+ for (;;) await reader.read();
430
+ }
431
+
432
+ it("gives up on a server that ignores Range and breaks at the same byte, whatever it sent first", async () => {
433
+ vi.stubGlobal(
434
+ "fetch",
435
+ vi.fn(async () => {
436
+ let sent = false;
437
+ const body = new ReadableStream<Uint8Array>({
438
+ pull(controller) {
439
+ if (sent) return controller.error(new TypeError("network error"));
440
+ sent = true;
441
+ controller.enqueue(new Uint8Array(64 * 1024));
442
+ },
443
+ });
444
+ return new Response(body, { status: 200 });
445
+ }),
446
+ );
447
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
448
+ const delays: (number | null)[] = [];
449
+ // A 200 answers from byte 0, so mediabunny resumes at 64 KiB and is sent byte 0 again.
450
+ for (const range of ["bytes=0-", "bytes=65536-", "bytes=65536-"]) {
451
+ const failure = await readUntilBroken(fetchFn, range).catch((e: unknown) => e);
452
+ delays.push(getRetryDelay(1, failure));
453
+ }
454
+
455
+ expect(delays).toEqual([0.5, 1, null]);
456
+ });
457
+
458
+ it("gives up on a region that keeps failing while another region of the same reader streams", async () => {
459
+ vi.stubGlobal(
460
+ "fetch",
461
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
462
+ const start = Number(/\d+/.exec(new Headers(init?.headers).get("Range") ?? "")?.[0]);
463
+ if (start >= 500_000) return new Response("", { status: 503 });
464
+ const headers = { "Content-Range": `bytes ${start}-999999/1000000` };
465
+ return new Response(new Uint8Array(1024), { status: 206, headers });
466
+ }),
467
+ );
468
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
469
+ const delays: (number | null)[] = [];
470
+ for (const healthy of [0, 1024, 2048]) {
471
+ await (
472
+ await fetchFn(URL_WITH_PATH, { headers: { Range: `bytes=${healthy}-` } })
473
+ ).arrayBuffer();
474
+ const failure = await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=600000-" } }).catch(
475
+ (e: unknown) => e,
476
+ );
477
+ delays.push(getRetryDelay(1, failure));
478
+ }
479
+
480
+ expect(delays).toEqual([0.5, 1, null]);
481
+ });
482
+
483
+ it("keeps a budget for each start, so failures on many clips of one reader never add up", async () => {
484
+ vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new TypeError("Failed to fetch")));
485
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
486
+ const failAt = async (start: number) =>
487
+ getRetryDelay(
488
+ 1,
489
+ await fetchFn(URL_WITH_PATH, { headers: { Range: `bytes=${start}-` } }).catch(
490
+ (e: unknown) => e,
491
+ ),
492
+ );
493
+ const spread = [];
494
+ for (const start of [0, 1000, 2000, 3000, 4000]) spread.push(await failAt(start));
495
+ const repeated = [await failAt(5000), await failAt(5000), await failAt(5000)];
496
+
497
+ expect(spread).toEqual([0.5, 0.5, 0.5, 0.5, 0.5]);
498
+ expect(repeated).toEqual([0.5, 1, null]);
499
+ });
500
+
501
+ it("forgets a start's failures once a read from it ends cleanly, so a long-lived reader meeting it again retries", async () => {
502
+ const headers = { "Content-Range": "bytes 5000-6023/1000000" };
503
+ vi.stubGlobal(
504
+ "fetch",
505
+ vi
506
+ .fn()
507
+ .mockRejectedValueOnce(new TypeError("Failed to fetch"))
508
+ .mockRejectedValueOnce(new TypeError("Failed to fetch"))
509
+ .mockResolvedValueOnce(new Response(new Uint8Array(1024), { status: 206, headers }))
510
+ .mockRejectedValue(new TypeError("Failed to fetch")),
511
+ );
512
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
513
+ const read5000 = () => fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=5000-" } });
514
+ const failAt5000 = async () => getRetryDelay(1, await read5000().catch((e: unknown) => e));
515
+ const early = [await failAt5000(), await failAt5000()];
516
+ await (await read5000()).arrayBuffer();
517
+ const later = [await failAt5000(), await failAt5000(), await failAt5000()];
518
+
519
+ expect(early).toEqual([0.5, 1]);
520
+ expect(later).toEqual([0.5, 1, null]);
521
+ });
522
+
523
+ it("forgets a start's failures when mediabunny stops a read from it at its target", async () => {
524
+ const headers = { "Content-Range": "bytes 5000-999999/1000000" };
525
+ const endless = () =>
526
+ new ReadableStream<Uint8Array>({ pull: (c) => c.enqueue(new Uint8Array(4096)) });
527
+ vi.stubGlobal(
528
+ "fetch",
529
+ vi
530
+ .fn()
531
+ .mockRejectedValueOnce(new TypeError("Failed to fetch"))
532
+ .mockRejectedValueOnce(new TypeError("Failed to fetch"))
533
+ .mockResolvedValueOnce(new Response(endless(), { status: 206, headers }))
534
+ .mockRejectedValue(new TypeError("Failed to fetch")),
535
+ );
536
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
537
+ const read5000 = (signal?: AbortSignal) =>
538
+ fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=5000-" }, signal });
539
+ const failAt5000 = async () => getRetryDelay(1, await read5000().catch((e: unknown) => e));
540
+ const early = [await failAt5000(), await failAt5000()];
541
+ // what mediabunny's _runWorker does once a read reaches its target: abort the signal it passed
542
+ const target = new AbortController();
543
+ const reader = (await read5000(target.signal)).body!.getReader();
544
+ await reader.read();
545
+ target.abort();
546
+ await reader.read().catch(() => {});
547
+ const later = [await failAt5000(), await failAt5000(), await failAt5000()];
548
+
549
+ expect(early).toEqual([0.5, 1]);
550
+ expect(later).toEqual([0.5, 1, null]);
551
+ });
552
+
553
+ it("keeps a start's failures when its read broke before mediabunny stopped it", async () => {
554
+ const headers = { "Content-Range": "bytes 5000-999999/1000000" };
555
+ let sent = false;
556
+ const breaking = new ReadableStream<Uint8Array>({
557
+ pull(controller) {
558
+ if (sent) return controller.error(new TypeError("network error"));
559
+ sent = true;
560
+ controller.enqueue(new Uint8Array(4096));
561
+ },
562
+ });
563
+ vi.stubGlobal(
564
+ "fetch",
565
+ vi
566
+ .fn()
567
+ .mockResolvedValueOnce(new Response(breaking, { status: 206, headers }))
568
+ .mockRejectedValue(new TypeError("Failed to fetch")),
569
+ );
570
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
571
+ const target = new AbortController();
572
+ const reader = (
573
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=5000-" }, signal: target.signal })
574
+ ).body!.getReader();
575
+ await reader.read();
576
+ const broken = await reader.read().catch((e: unknown) => e);
577
+ const delays = [getRetryDelay(1, broken)];
578
+ target.abort();
579
+ for (let i = 0; i < 2; i++) {
580
+ const failure = await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=5000-" } }).catch(
581
+ (e: unknown) => e,
582
+ );
583
+ delays.push(getRetryDelay(1, failure));
584
+ }
585
+
586
+ expect(delays).toEqual([0.5, 1, null]);
587
+ });
588
+
589
+ it("keeps counting a start's failures however far apart they come, while no read from it ends", async () => {
590
+ vi.useFakeTimers({ now: Date.UTC(2026, 9, 28, 9, 0, 0) });
591
+ vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new TypeError("Failed to fetch")));
592
+ const { fetchFn, getRetryDelay } = mediaUrlSourceOptions("thumbnail");
593
+ const delays = [];
594
+ for (let i = 0; i < 3; i++) {
595
+ const failure = await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=5000-" } }).catch(
596
+ (e: unknown) => e,
597
+ );
598
+ delays.push(getRetryDelay(1, failure));
599
+ // a slow server streaming for minutes before it breaks
600
+ vi.setSystemTime(Date.now() + 20 * 60_000);
601
+ }
602
+ vi.useRealTimers();
603
+
604
+ expect(delays).toEqual([0.5, 1, null]);
605
+ });
606
+
116
607
  it("does not retry a client error status", () => {
117
608
  const failure = new MediaFetchError("probe", 404, null);
118
609
 
@@ -147,6 +638,87 @@ describe("mediaUrlSourceOptions", () => {
147
638
  });
148
639
  });
149
640
 
641
+ describe("thumbnail reads", () => {
642
+ // A 206 answering each request, with its Content-Range readable or (cross-origin, unexposed) hidden.
643
+ function rangeServer(answers: ("readable" | "hidden" | "whole" | { start: number })[]) {
644
+ const ranges: (string | null)[] = [];
645
+ vi.stubGlobal(
646
+ "fetch",
647
+ vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
648
+ const range = new Headers(init?.headers).get("Range");
649
+ ranges.push(range);
650
+ const answer = answers[ranges.length - 1] ?? "readable";
651
+ const start = typeof answer === "object" ? answer.start : Number(/\d+/.exec(range ?? "0"));
652
+ const headers =
653
+ answer === "hidden" ? {} : { "Content-Range": `bytes ${start}-9999999/10000000` };
654
+ return new Response("", { status: answer === "whole" ? 200 : 206, headers });
655
+ }),
656
+ );
657
+ return ranges;
658
+ }
659
+ const BOUND = 512 * 1024;
660
+
661
+ it("bounds an open-ended thumbnail range once this reader has read a Content-Range", async () => {
662
+ const ranges = rangeServer(["readable"]);
663
+ const { fetchFn } = mediaUrlSourceOptions("thumbnail");
664
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=0-" } });
665
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=1000-" } });
666
+ await fetchFn(URL_WITH_PATH, { headers: new Headers({ Range: "bytes=0-99" }) });
667
+ // A bounded answer's Content-Range is read too, so the reader stays bounded.
668
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=2000-" } });
669
+
670
+ // The first stays open-ended: without a readable Content-Range mediabunny sizes the file from it.
671
+ expect(ranges).toEqual([
672
+ "bytes=0-",
673
+ `bytes=1000-${1000 + BOUND - 1}`,
674
+ "bytes=0-99",
675
+ `bytes=2000-${2000 + BOUND - 1}`,
676
+ ]);
677
+ });
678
+
679
+ it("never bounds a reader once an answer hid its Content-Range", async () => {
680
+ const ranges = rangeServer(["hidden", "readable"]);
681
+ const { fetchFn } = mediaUrlSourceOptions("thumbnail");
682
+ for (const start of [0, 1000, 2000]) {
683
+ await fetchFn(URL_WITH_PATH, { headers: { Range: `bytes=${start}-` } });
684
+ }
685
+
686
+ expect(ranges).toEqual(["bytes=0-", "bytes=1000-", "bytes=2000-"]);
687
+ });
688
+
689
+ it("does not trust a Content-Range for a range it did not ask for", async () => {
690
+ const ranges = rangeServer([{ start: 4096 }]);
691
+ const { fetchFn } = mediaUrlSourceOptions("thumbnail");
692
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=0-" } });
693
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=1000-" } });
694
+
695
+ expect(ranges).toEqual(["bytes=0-", "bytes=1000-"]);
696
+ });
697
+
698
+ it("does not trust a whole-file answer, whatever its headers say", async () => {
699
+ const ranges = rangeServer(["whole"]);
700
+ const { fetchFn } = mediaUrlSourceOptions("thumbnail");
701
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=0-" } });
702
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=1000-" } });
703
+
704
+ expect(ranges).toEqual(["bytes=0-", "bytes=1000-"]);
705
+ });
706
+
707
+ it("never bounds a probe's range", async () => {
708
+ const ranges = rangeServer(["readable"]);
709
+ const { fetchFn } = mediaUrlSourceOptions("probe");
710
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=0-" } });
711
+ await fetchFn(URL_WITH_PATH, { headers: { Range: "bytes=1000-" } });
712
+
713
+ expect(ranges).toEqual(["bytes=0-", "bytes=1000-"]);
714
+ });
715
+
716
+ it("keeps a thumbnail reader's cache at 16 MiB, and a probe's at mediabunny's default", () => {
717
+ expect(mediaUrlSourceOptions("thumbnail")).toMatchObject({ maxCacheSize: 16 * 1024 * 1024 });
718
+ expect(mediaUrlSourceOptions("probe")).not.toHaveProperty("maxCacheSize");
719
+ });
720
+ });
721
+
150
722
  describe("reportMediaFetchFailure", () => {
151
723
  it("writes one scrubbed line for a typed failure and nothing for anything else", () => {
152
724
  const warn = vi.spyOn(console, "warn").mockImplementation(() => {});