@hyperframes/studio 0.8.210 → 0.8.211

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.
@@ -17,6 +17,7 @@ export class MediaFetchError extends Error {
17
17
  readonly reader: MediaReader,
18
18
  readonly status: number | null,
19
19
  readonly code: string | null,
20
+ readonly start: number | null = null,
20
21
  ) {
21
22
  super(describe(reader, status, code, 0));
22
23
  }
@@ -28,6 +29,31 @@ export class MediaFetchError extends Error {
28
29
  }
29
30
 
30
31
  const MAX_RETRIES = 2;
32
+ // Three silent waits plus the 0.5 s and 1 s retry delays (25.5 s) end inside thumbnailLoadTimeoutMs.
33
+ const SILENT_BODY_STALL_MS = 8_000;
34
+ // mediabunny cancels a `bytes=N-` read at its target, by when a local server has streamed megabytes past it.
35
+ const THUMBNAIL_RANGE_BYTES = 512 * 1024;
36
+ const POOLED_READER_CACHE_BYTES = 16 * 1024 * 1024;
37
+
38
+ const rangeStart = (init: RequestInit | undefined, closed: boolean) =>
39
+ (closed ? /^bytes=(\d+)-\d*$/ : /^bytes=(\d+)-$/).exec(
40
+ new Headers(init?.headers).get("Range") ?? "",
41
+ )?.[1];
42
+
43
+ function boundedRange(init: RequestInit | undefined): RequestInit | undefined {
44
+ const start = rangeStart(init, false);
45
+ if (start === undefined) return init;
46
+ const headers = new Headers(init?.headers);
47
+ headers.set("Range", `bytes=${start}-${Number(start) + THUMBNAIL_RANGE_BYTES - 1}`);
48
+ return { ...init, headers };
49
+ }
50
+
51
+ /** Without a readable Content-Range (hidden cross-origin unless exposed) mediabunny sizes the file from this answer. */
52
+ function rangesReadable(init: RequestInit | undefined, response: Response): boolean {
53
+ const asked = rangeStart(init, true);
54
+ const shown = /^bytes (\d+)-\d+\/\d+$/.exec(response.headers.get("Content-Range") ?? "")?.[1];
55
+ return response.status === 206 && asked !== undefined && shown === asked;
56
+ }
31
57
 
32
58
  const isAbort = (error: unknown) => (error as { name?: unknown } | null)?.name === "AbortError";
33
59
 
@@ -38,58 +64,139 @@ function networkCode(error: unknown): string {
38
64
  return typeof name === "string" ? name : "unknown";
39
65
  }
40
66
 
41
- const typedFailure = (reader: MediaReader, error: unknown) =>
42
- isAbort(error) ? error : new MediaFetchError(reader, null, networkCode(error));
67
+ const typedFailure = (reader: MediaReader, error: unknown, start: number) =>
68
+ isAbort(error) ? error : new MediaFetchError(reader, null, networkCode(error), start);
69
+
70
+ /**
71
+ * A stalled body ignores every signal, so a silent one is aborted. The wait for the answer is not
72
+ * timed: it includes Chrome's queue for a connection, which streaming previews can hold for long.
73
+ */
74
+ function watchedRequest(reader: MediaReader, parents: readonly AbortSignal[]) {
75
+ const controller = new AbortController();
76
+ let stalled = false;
77
+ let timer: ReturnType<typeof setTimeout> | undefined;
78
+ const unlinks = parents.map((parent) => {
79
+ const follow = () => controller.abort(parent.reason);
80
+ parent.addEventListener("abort", follow, { once: true });
81
+ return () => parent.removeEventListener("abort", follow);
82
+ });
83
+ const done = () => {
84
+ clearTimeout(timer);
85
+ for (const unlink of unlinks.splice(0)) unlink();
86
+ };
87
+ controller.signal.addEventListener("abort", done, { once: true });
88
+ for (const parent of parents) if (parent.aborted) controller.abort(parent.reason);
89
+ const wait = <T>(pending: Promise<T>): Promise<T> => {
90
+ if (reader !== "thumbnail") return pending;
91
+ return new Promise<T>((resolve, reject) => {
92
+ timer = setTimeout(() => {
93
+ stalled = true;
94
+ const reason = new DOMException(`No bytes for ${SILENT_BODY_STALL_MS} ms`, "TimeoutError");
95
+ reject(reason);
96
+ controller.abort(reason);
97
+ }, SILENT_BODY_STALL_MS);
98
+ void pending.then(resolve, reject).finally(() => clearTimeout(timer));
99
+ });
100
+ };
101
+ const failure = (error: unknown, start: number) =>
102
+ stalled
103
+ ? new MediaFetchError(reader, null, "stalled", start)
104
+ : typedFailure(reader, error, start);
105
+ return { signal: controller.signal, wait, done, failure };
106
+ }
107
+
108
+ type WatchedRequest = ReturnType<typeof watchedRequest>;
43
109
 
44
110
  /** The body, failing a broken read with a MediaFetchError: mediabunny rethrows a body error as-is. */
45
111
  function typedBody(
46
- reader: MediaReader,
47
112
  body: ReadableStream<Uint8Array>,
113
+ start: number,
114
+ request: WatchedRequest,
48
115
  ): ReadableStream<Uint8Array> {
49
116
  const source = body.getReader();
50
117
  return new ReadableStream<Uint8Array>({
51
118
  async pull(controller) {
52
119
  try {
53
- const { done, value } = await source.read();
54
- if (done) controller.close();
55
- else controller.enqueue(value);
120
+ const { done, value } = await request.wait(source.read());
121
+ if (!done) return controller.enqueue(value);
122
+ request.done();
123
+ controller.close();
56
124
  } catch (error) {
57
- controller.error(typedFailure(reader, error));
125
+ request.done();
126
+ controller.error(request.failure(error, start));
58
127
  }
59
128
  },
60
- cancel: (reason) => source.cancel(reason),
129
+ cancel: (reason) => {
130
+ request.done();
131
+ return source.cancel(reason);
132
+ },
61
133
  });
62
134
  }
63
135
 
136
+ async function typedFetch(
137
+ reader: MediaReader,
138
+ input: RequestInfo | URL,
139
+ sent: RequestInit,
140
+ asked: number,
141
+ request: WatchedRequest,
142
+ ): Promise<Response> {
143
+ let response: Response;
144
+ try {
145
+ // oxlint-disable-next-line no-restricted-globals -- a media read, on the media's sockets like mediabunny's own
146
+ response = await fetch(input, { ...sent, signal: request.signal });
147
+ } catch (error) {
148
+ request.done();
149
+ throw request.failure(error, asked);
150
+ }
151
+ if (response.ok) return response;
152
+ request.done();
153
+ throw new MediaFetchError(reader, response.status, null, asked);
154
+ }
155
+
156
+ function typedResponse(response: Response, asked: number, request: WatchedRequest): Response {
157
+ if (!response.body) {
158
+ request.done();
159
+ return response;
160
+ }
161
+ const { status, statusText, headers } = response;
162
+ const body = typedBody(response.body, status === 206 ? asked : 0, request);
163
+ return new Response(body, { status, statusText, headers });
164
+ }
165
+
64
166
  /**
65
167
  * Options for a mediabunny `UrlSource`. Its default retries a same-origin network failure
66
168
  * forever and logs a bare `TypeError` each time; these retry twice and fail with a MediaFetchError.
67
169
  */
68
170
  export function mediaUrlSourceOptions(reader: MediaReader) {
69
- let failures = 0;
171
+ // Per start byte: a resume asks for a new start, while asking for one again uses its budget up.
172
+ const failuresByStart = new Map<number | null, number>();
173
+ const inFlightReads = new AbortController();
174
+ let ranges: "unknown" | "readable" | "hidden" = reader === "thumbnail" ? "unknown" : "hidden";
70
175
  const fetchFn = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
71
- let response: Response;
72
- try {
73
- // oxlint-disable-next-line no-restricted-globals -- a media read, on the media's sockets like mediabunny's own
74
- response = await fetch(input, init);
75
- } catch (error) {
76
- throw typedFailure(reader, error);
77
- }
78
- if (!response.ok) throw new MediaFetchError(reader, response.status, null);
79
- if (!response.body) return response;
80
- const { status, statusText, headers } = response;
81
- return new Response(typedBody(reader, response.body), { status, statusText, headers });
176
+ const sent = ranges === "readable" ? boundedRange(init) : init;
177
+ const asked = Number(rangeStart(sent, true) ?? 0);
178
+ const request = watchedRequest(
179
+ reader,
180
+ init?.signal ? [inFlightReads.signal, init.signal] : [inFlightReads.signal],
181
+ );
182
+ const response = await typedFetch(reader, input, sent ?? {}, asked, request);
183
+ if (ranges !== "hidden") ranges = rangesReadable(sent, response) ? "readable" : "hidden";
184
+ return typedResponse(response, asked, request);
82
185
  };
83
- // Counted per source: mediabunny passes 1 for every failed mid-stream read.
84
186
  const getRetryDelay = (_previousAttempts: number, error: unknown): number | null => {
187
+ const start = error instanceof MediaFetchError ? error.start : null;
188
+ const failed = failuresByStart.get(start) ?? 0;
85
189
  const clientError =
86
190
  error instanceof MediaFetchError && error.status !== null && error.status < 500;
87
- if (error instanceof MediaFetchError) error.setRetries(failures);
88
- if (clientError || failures >= MAX_RETRIES) return null;
89
- failures++;
90
- return 0.5 * failures;
191
+ if (error instanceof MediaFetchError) error.setRetries(failed);
192
+ if (clientError || failed >= MAX_RETRIES) return null;
193
+ failuresByStart.set(start, failed + 1);
194
+ return 0.5 * (failed + 1);
91
195
  };
92
- return { fetchFn, getRetryDelay };
196
+ const cancelReads = () =>
197
+ inFlightReads.abort(new DOMException("Media reads cancelled", "AbortError"));
198
+ if (reader === "probe") return { fetchFn, getRetryDelay, cancelReads };
199
+ return { fetchFn, getRetryDelay, cancelReads, maxCacheSize: POOLED_READER_CACHE_BYTES };
93
200
  }
94
201
 
95
202
  export function reportMediaFetchFailure(error: unknown): void {
@@ -0,0 +1,69 @@
1
+ /** One decoded video frame, shared by every strip of its source that accepts it. */
2
+ export interface SharedFrame {
3
+ url: string;
4
+ decodedAt: number;
5
+ bytes: number;
6
+ users: number;
7
+ }
8
+
9
+ export interface HeldFrame {
10
+ key: string;
11
+ frame: SharedFrame;
12
+ }
13
+
14
+ const sharedFrames = new Map<string, SharedFrame[]>();
15
+ // Frames no strip shows, least recently released first; their URLs stay valid until evicted.
16
+ const released = new Map<SharedFrame, string>();
17
+ let releasedBytes = 0;
18
+
19
+ function use(frame: SharedFrame): SharedFrame {
20
+ if (frame.users++ === 0 && released.delete(frame)) releasedBytes -= frame.bytes;
21
+ return frame;
22
+ }
23
+
24
+ export function takeSharedFrame(
25
+ key: string,
26
+ accepts: (decodedAt: number) => boolean,
27
+ ): SharedFrame | undefined {
28
+ const frame = sharedFrames.get(key)?.find((shared) => accepts(shared.decodedAt));
29
+ return frame && use(frame);
30
+ }
31
+
32
+ export function shareFrame(
33
+ key: string,
34
+ decodedAt: number,
35
+ url: string,
36
+ bytes: number,
37
+ ): SharedFrame {
38
+ const frames = sharedFrames.get(key) ?? [];
39
+ const existing = frames.find((shared) => shared.decodedAt === decodedAt);
40
+ if (existing) {
41
+ URL.revokeObjectURL(url);
42
+ return use(existing);
43
+ }
44
+ const frame = { url, decodedAt, bytes, users: 1 };
45
+ sharedFrames.set(key, [...frames, frame]);
46
+ return frame;
47
+ }
48
+
49
+ function evict(frame: SharedFrame, key: string): void {
50
+ released.delete(frame);
51
+ releasedBytes -= frame.bytes;
52
+ const rest = sharedFrames.get(key)?.filter((shared) => shared !== frame) ?? [];
53
+ if (rest.length > 0) sharedFrames.set(key, rest);
54
+ else sharedFrames.delete(key);
55
+ URL.revokeObjectURL(frame.url);
56
+ }
57
+
58
+ /** Ends these holds; a frame nobody holds stays shared until released frames pass `budgetBytes`. */
59
+ export function releaseSharedFrames(held: HeldFrame[], budgetBytes: number): void {
60
+ for (const { key, frame } of held.splice(0)) {
61
+ if (--frame.users > 0) continue;
62
+ released.set(frame, key);
63
+ releasedBytes += frame.bytes;
64
+ }
65
+ for (const [frame, key] of released) {
66
+ if (releasedBytes <= budgetBytes) break;
67
+ evict(frame, key);
68
+ }
69
+ }
@@ -0,0 +1,86 @@
1
+ import { afterEach, describe, expect, it, vi } from "vitest";
2
+ import { usePlayerStore } from "../store/playerStore";
3
+ import { bindThumbnailPlaybackHold } from "./thumbnailPlaybackHold";
4
+ import {
5
+ ThumbnailScheduler,
6
+ thumbnailScheduler,
7
+ type ThumbnailLoadedResult,
8
+ type ThumbnailRequest,
9
+ } from "./thumbnailScheduler";
10
+
11
+ const decoded = (): ThumbnailLoadedResult => ({
12
+ value: { kind: "image", url: "frame", aspect: 1 },
13
+ weight: 1,
14
+ });
15
+
16
+ let requests = 0;
17
+ function videoRequest(load: ThumbnailRequest["load"]): ThumbnailRequest {
18
+ return {
19
+ key: `video-${++requests}`,
20
+ projectId: "project-a",
21
+ sessionEpoch: 1,
22
+ kind: "video",
23
+ priority: "visible",
24
+ load,
25
+ };
26
+ }
27
+
28
+ const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
29
+
30
+ afterEach(() => usePlayerStore.getState().reset());
31
+
32
+ describe("bindThumbnailPlaybackHold", () => {
33
+ it("holds video decodes while the store plays, and lets them go when a reset stops it", async () => {
34
+ const scheduler = new ThumbnailScheduler();
35
+ const unbind = bindThumbnailPlaybackHold(usePlayerStore, scheduler);
36
+ try {
37
+ usePlayerStore.getState().setIsPlaying(true);
38
+ const held = vi.fn(async () => decoded());
39
+ scheduler.acquire(videoRequest(held), vi.fn());
40
+ await settle();
41
+ expect(held).not.toHaveBeenCalled();
42
+
43
+ // reset() writes isPlaying: false itself, without setIsPlaying.
44
+ usePlayerStore.getState().reset();
45
+ await settle();
46
+ expect(held).toHaveBeenCalledTimes(1);
47
+
48
+ usePlayerStore.getState().setIsPlaying(true);
49
+ const nextProject = vi.fn(async () => decoded());
50
+ scheduler.acquire(videoRequest(nextProject), vi.fn());
51
+ usePlayerStore.getState().beginTimelineSession(`project-${requests}`);
52
+ await settle();
53
+ expect(nextProject).toHaveBeenCalledTimes(1);
54
+ } finally {
55
+ unbind();
56
+ }
57
+ });
58
+
59
+ it("reads the store as it is when bound, and stops following it once unbound", async () => {
60
+ const scheduler = new ThumbnailScheduler();
61
+ usePlayerStore.getState().setIsPlaying(true);
62
+ const unbind = bindThumbnailPlaybackHold(usePlayerStore, scheduler);
63
+ const held = vi.fn(async () => decoded());
64
+ scheduler.acquire(videoRequest(held), vi.fn());
65
+ await settle();
66
+ expect(held).not.toHaveBeenCalled();
67
+
68
+ unbind();
69
+ usePlayerStore.getState().setIsPlaying(false);
70
+ await settle();
71
+ expect(held).not.toHaveBeenCalled();
72
+ });
73
+
74
+ it("holds the app's scheduler once video thumbnails are loaded", async () => {
75
+ await import("../components/VideoThumbnail");
76
+ usePlayerStore.getState().setIsPlaying(true);
77
+ const held = vi.fn(async () => decoded());
78
+ const lease = thumbnailScheduler.acquire(videoRequest(held), vi.fn());
79
+ await settle();
80
+ expect(held).not.toHaveBeenCalled();
81
+ usePlayerStore.getState().setIsPlaying(false);
82
+ await settle();
83
+ expect(held).toHaveBeenCalledTimes(1);
84
+ lease.release();
85
+ });
86
+ });
@@ -0,0 +1,15 @@
1
+ import type { ThumbnailScheduler } from "./thumbnailScheduler";
2
+
3
+ interface PlaybackStore {
4
+ getState(): { isPlaying: boolean };
5
+ subscribe(listener: (state: { isPlaying: boolean }) => void): () => void;
6
+ }
7
+
8
+ /** Subscribed to the state, not to setIsPlaying, so a reset that writes isPlaying: false also lets go. */
9
+ export function bindThumbnailPlaybackHold(
10
+ store: PlaybackStore,
11
+ scheduler: Pick<ThumbnailScheduler, "setPlaybackActive">,
12
+ ): () => void {
13
+ scheduler.setPlaybackActive(store.getState().isPlaying);
14
+ return store.subscribe((state) => scheduler.setPlaybackActive(state.isPlaying));
15
+ }
@@ -153,6 +153,53 @@ describe("ThumbnailScheduler", () => {
153
153
  expect(richLoad).toHaveBeenCalledTimes(1);
154
154
  });
155
155
 
156
+ it("starts no visible or overscan video decode while the preview plays, but still a scrub's", async () => {
157
+ const scheduler = new ThumbnailScheduler();
158
+ const starts: string[] = [];
159
+ const load = (name: string) =>
160
+ vi.fn(async () => {
161
+ starts.push(name);
162
+ return result(name);
163
+ });
164
+ const video = { kind: "video" as const };
165
+ scheduler.setPlaybackActive(true);
166
+
167
+ const visible = scheduler.acquire(
168
+ request("visible", load("visible"), "visible", video),
169
+ vi.fn(),
170
+ );
171
+ scheduler.acquire(request("overscan", load("overscan"), "overscan", video), vi.fn());
172
+ scheduler.acquire(request("scrub", load("scrub"), "interaction", video), vi.fn());
173
+ scheduler.acquire(request("image", load("image"), "visible"), vi.fn());
174
+ await flush();
175
+ expect(starts).toEqual(["scrub", "image"]);
176
+
177
+ visible.updatePriority("interaction");
178
+ await flush();
179
+ expect(starts).toEqual(["scrub", "image", "visible"]);
180
+ });
181
+
182
+ it("drains the video decodes it held once playback pauses", async () => {
183
+ const scheduler = new ThumbnailScheduler();
184
+ const starts: string[] = [];
185
+ const load = (name: string) =>
186
+ vi.fn(async () => {
187
+ starts.push(name);
188
+ return result(name);
189
+ });
190
+ scheduler.setPlaybackActive(true);
191
+ scheduler.acquire(request("visible", load("visible"), "visible", { kind: "video" }), vi.fn());
192
+ scheduler.acquire(
193
+ request("overscan", load("overscan"), "overscan", { kind: "video" }),
194
+ vi.fn(),
195
+ );
196
+ await flush();
197
+ expect(starts).toEqual([]);
198
+
199
+ scheduler.setPlaybackActive(false);
200
+ await vi.waitFor(() => expect(starts).toEqual(["visible", "overscan"]));
201
+ });
202
+
156
203
  it("holds composition renders while the preview reloads and re-runs the ones it preempted", async () => {
157
204
  const scheduler = new ThumbnailScheduler();
158
205
  const signals: AbortSignal[] = [];
@@ -336,6 +383,8 @@ describe("ThumbnailScheduler", () => {
336
383
  await vi.advanceTimersByTimeAsync(11);
337
384
  await flush();
338
385
  expect(signal?.aborted).toBe(true);
386
+ // Said apart from a cancel: a job that timed out without progress failed its source.
387
+ expect(signal?.reason).toMatchObject({ name: "TimeoutError" });
339
388
  expect(nextLoad).toHaveBeenCalledTimes(1);
340
389
  expect(scheduler.getSnapshot(hungRequest).status).toBe("error");
341
390
 
@@ -117,6 +117,7 @@ export class ThumbnailScheduler {
117
117
  private nextSequence = 1;
118
118
  private scrolling = false;
119
119
  private previewReloading = false;
120
+ private playbackActive = false;
120
121
  private pageHidden = false;
121
122
  private cacheBytes = 0;
122
123
  private waveformCacheBytes = 0;
@@ -231,6 +232,12 @@ export class ThumbnailScheduler {
231
232
  }
232
233
  }
233
234
 
235
+ setPlaybackActive(active: boolean): void {
236
+ if (this.playbackActive === active) return;
237
+ this.playbackActive = active;
238
+ if (!active) this.pump();
239
+ }
240
+
234
241
  setPageHidden(hidden: boolean): void {
235
242
  if (this.pageHidden === hidden) return;
236
243
  this.pageHidden = hidden;
@@ -295,14 +302,24 @@ export class ThumbnailScheduler {
295
302
  });
296
303
 
297
304
  for (const entry of queued) {
298
- if (this.scrolling && entry.request.rich) continue;
299
- if (this.previewReloading && entry.request.kind === "composition") continue;
305
+ if (this.isHeld(entry)) continue;
300
306
  const bucket = concurrencyBucket(entry.request.kind);
301
307
  if (this.activeByBucket[bucket] >= this.bucketLimit(bucket)) continue;
302
308
  this.start(entry, bucket);
303
309
  }
304
310
  }
305
311
 
312
+ private isHeld(entry: ThumbnailEntry): boolean {
313
+ const { kind, rich } = entry.request;
314
+ if (this.scrolling && rich) return true;
315
+ if (this.previewReloading && kind === "composition") return true;
316
+ return (
317
+ this.playbackActive &&
318
+ kind === "video" &&
319
+ this.entryPriority(entry) < PRIORITY_SCORE.interaction
320
+ );
321
+ }
322
+
306
323
  private start(entry: ThumbnailEntry, bucket: "video" | "composition" | "general"): void {
307
324
  entry.state = "loading";
308
325
  entry.snapshot = Object.freeze({ status: "loading" });
@@ -476,10 +493,9 @@ export class ThumbnailScheduler {
476
493
  const timeout = setTimeout(() => {
477
494
  if (settled) return;
478
495
  settled = true;
479
- controller.abort();
480
- reject(
481
- new Error(`Thumbnail load timed out after ${this.budgets.thumbnailLoadTimeoutMs}ms`),
482
- );
496
+ const message = `Thumbnail load timed out after ${this.budgets.thumbnailLoadTimeoutMs}ms`;
497
+ controller.abort(new DOMException(message, "TimeoutError"));
498
+ reject(new Error(message));
483
499
  }, this.budgets.thumbnailLoadTimeoutMs);
484
500
 
485
501
  load.then(
@@ -0,0 +1,163 @@
1
+ import type { Input, InputVideoTrack } from "mediabunny";
2
+ import { mediaUrlSourceOptions } from "./mediaFetch";
3
+
4
+ export interface SourceInfo {
5
+ aspect: number;
6
+ metadataDuration: number | null;
7
+ }
8
+
9
+ type Mediabunny = typeof import("mediabunny");
10
+
11
+ interface OpenedSource {
12
+ mediabunny: Mediabunny;
13
+ track: InputVideoTrack;
14
+ info: SourceInfo;
15
+ }
16
+
17
+ export interface ThumbnailSource extends OpenedSource {
18
+ /** Ends this job's use. A failed job retires the reader, so the next job opens a fresh one. */
19
+ release(failed: boolean): void;
20
+ /** The job waited for the reader to open: the open finishing was progress the job saw. */
21
+ waitedForOpen: boolean;
22
+ progress: { framesFromAnyJob: number };
23
+ }
24
+
25
+ interface PooledSource {
26
+ version: string | undefined;
27
+ input: Input | null;
28
+ cancelReads: (() => void) | null;
29
+ ready: boolean;
30
+ opened: Promise<OpenedSource>;
31
+ users: number;
32
+ progress: { framesFromAnyJob: number };
33
+ idleTimer: ReturnType<typeof setTimeout> | null;
34
+ disposed: boolean;
35
+ }
36
+
37
+ // One reader per source URL, shared by every clip cut from it: the index is parsed once.
38
+ const pool = new Map<string, PooledSource>();
39
+ let mediabunnyModule: Promise<Mediabunny> | null = null;
40
+ const loadMediabunny = () => (mediabunnyModule ??= import("mediabunny"));
41
+
42
+ const abortError = () => new DOMException("Aborted", "AbortError");
43
+ /** The scheduler's own timeout, as opposed to a cancel. */
44
+ export const timedOut = (signal: AbortSignal) =>
45
+ (signal.reason as { name?: unknown } | null)?.name === "TimeoutError";
46
+ const isAbortError = (error: unknown) =>
47
+ (error as { name?: unknown } | null)?.name === "AbortError";
48
+
49
+ function dispose(source: string, entry: PooledSource): void {
50
+ if (entry.disposed) return;
51
+ entry.disposed = true;
52
+ if (entry.idleTimer !== null) clearTimeout(entry.idleTimer);
53
+ if (pool.get(source) === entry) pool.delete(source);
54
+ entry.input?.dispose();
55
+ entry.cancelReads?.();
56
+ }
57
+
58
+ function retire(source: string, entry: PooledSource): void {
59
+ if (pool.get(source) === entry) pool.delete(source);
60
+ if (entry.users === 0) dispose(source, entry);
61
+ }
62
+
63
+ async function open(source: string, pooled: () => PooledSource): Promise<OpenedSource> {
64
+ const mediabunny = await loadMediabunny();
65
+ const entry = pooled();
66
+ // A reader every job let go of while it opened was disposed: stop before reading more of it.
67
+ const live = () => {
68
+ if (entry.disposed) throw abortError();
69
+ };
70
+ live();
71
+ const options = mediaUrlSourceOptions("thumbnail");
72
+ const input = new mediabunny.Input({
73
+ source: new mediabunny.UrlSource(source, options),
74
+ formats: mediabunny.ALL_FORMATS,
75
+ });
76
+ entry.input = input;
77
+ entry.cancelReads = options.cancelReads;
78
+ const track = await input.getPrimaryVideoTrack();
79
+ live();
80
+ if (!track) throw new Error("Video source has no decodable video track");
81
+ const [displayWidth, displayHeight] = await Promise.all([
82
+ track.getDisplayWidth(),
83
+ track.getDisplayHeight(),
84
+ ]);
85
+ live();
86
+ if (!(displayWidth > 0 && displayHeight > 0)) {
87
+ throw new Error("Video source has invalid dimensions");
88
+ }
89
+ const metadataDuration = await track.getDurationFromMetadata({ skipLiveWait: true });
90
+ live();
91
+ return { mediabunny, track, info: { aspect: displayWidth / displayHeight, metadataDuration } };
92
+ }
93
+
94
+ function pooledSource(source: string, version: string | undefined): PooledSource {
95
+ const current = pool.get(source);
96
+ if (current && current.version === version) return current;
97
+ if (current) retire(source, current);
98
+ const entry: PooledSource = {
99
+ version,
100
+ input: null,
101
+ cancelReads: null,
102
+ ready: false,
103
+ opened: open(source, () => entry),
104
+ users: 0,
105
+ progress: { framesFromAnyJob: 0 },
106
+ idleTimer: null,
107
+ disposed: false,
108
+ };
109
+ // A failed open leaves the pool at once; the jobs awaiting it see the failure themselves.
110
+ entry.opened.then(
111
+ () => (entry.ready = true),
112
+ () => retire(source, entry),
113
+ );
114
+ pool.set(source, entry);
115
+ return entry;
116
+ }
117
+
118
+ function untilAborted<T>(pending: Promise<T>, signal: AbortSignal): Promise<T> {
119
+ if (signal.aborted) return Promise.reject(abortError());
120
+ return new Promise<T>((resolve, reject) => {
121
+ const onAbort = () => reject(abortError());
122
+ signal.addEventListener("abort", onAbort, { once: true });
123
+ void pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
124
+ });
125
+ }
126
+
127
+ /**
128
+ * The opened reader for `source` at `version`, shared by concurrent jobs and kept for `idleMs`
129
+ * after the last one ends (0 disposes at once). A new version retires the old reader.
130
+ */
131
+ export async function acquireThumbnailSource(
132
+ source: string,
133
+ version: string | undefined,
134
+ signal: AbortSignal,
135
+ idleMs: number,
136
+ ): Promise<ThumbnailSource> {
137
+ const entry = pooledSource(source, version);
138
+ const waitedForOpen = !entry.ready;
139
+ entry.users += 1;
140
+ if (entry.idleTimer !== null) clearTimeout(entry.idleTimer);
141
+ entry.idleTimer = null;
142
+ let released = false;
143
+ const release = (failed: boolean) => {
144
+ if (released) return;
145
+ released = true;
146
+ entry.users -= 1;
147
+ if (failed) retire(source, entry);
148
+ if (entry.users > 0 || entry.disposed) return;
149
+ if (pool.get(source) === entry && idleMs > 0) {
150
+ entry.idleTimer = setTimeout(() => dispose(source, entry), idleMs);
151
+ } else {
152
+ dispose(source, entry);
153
+ }
154
+ };
155
+ try {
156
+ const { progress } = entry;
157
+ return { ...(await untilAborted(entry.opened, signal)), release, waitedForOpen, progress };
158
+ } catch (error) {
159
+ // Timed out still waiting: the open made no progress in the job's whole run.
160
+ release(!isAbortError(error) || timedOut(signal));
161
+ throw error;
162
+ }
163
+ }