@tongue-core/ui 0.1.0-rc.7 → 0.1.0-rc.9

package/dist/player/player.js

@@ -7,6 +7,7 @@ import { Cancelled, WorkerPool } from "./pool.js";
 import { bufferedAhead, clampFrame, startBuffer, wantedFrames } from "./schedule.js";
 import { openFilm } from "./source.js";
 import { Transport } from "./transport.js";
+import { CANCELLED_PREVIEW } from "./protocol.js";
 /** Which workers use a file: audio the soundtrack's, proxy segments the video worker, a video's
  *  facts both (frames lay out with them; the decoder reads its proxy from them), the rest frames. */
 function fileFor(path, audio) {
@@ -82,8 +83,23 @@ export function createPlayer(options) {
         emit("error", { message: text });
     }
     const bounds = (s) => ({ first: range?.from ?? 0, last: Math.min(s.length - 1, range?.to ?? s.length - 1) });
-    const frameReady = (s) => (frame) => s.needs.pathsAt(frame).every(s.loader.isReady);
-    const audioReady = (s) => s.needs.audio.every(s.loader.isReady);
+    const frameReady = (s) => (frame) => !s.blocked.has(frame) && s.needs.pathsAt(frame).every(s.loader.isReady);
+    const audioReady = (s) => s.needs.audioPathsIn(transport.playhead, transport.playhead + s.fps * 5).every(s.loader.isReady);
+    pool.onMediaNeed = (paths) => {
+        const s = session;
+        if (!s)
+            return;
+        for (const path of paths) {
+            s.demand.set(path, transport.playhead);
+            if (s.loader.status(path) === null)
+                s.loader.failMissing(path);
+            if (s.loader.status(path) === "failed")
+                pool.mediaFailed(path, s.loader.error(path) ?? "Media failed");
+            if (s.loader.isReady(path))
+                deliverTo(s, path);
+        }
+        s.loader.want(paths, 0);
+    };
     function requestTick() {
         if (tickQueued || disposed)
             return;
@@ -131,7 +147,7 @@ export function createPlayer(options) {
         const playing = transport.state !== "paused";
         const wants = wantedFrames({
             playhead: transport.playhead, playing, moving: !playing && moving(), first, last, fps: s.fps, scales, ahead,
-            cachedScale: (f) => cache.scaleOf(f),
+            cachedScale: (f) => { const value = cache.get(f); return value && (value.exact || !s.bounded) ? value.scale : null; },
             rendering: (f, scale) => pool.wants(f, scale),
             ready: frameReady(s),
         });
@@ -145,22 +161,37 @@ export function createPlayer(options) {
                 if (session !== s)
                     return result.pixels.bitmap.close();
                 cache.put(result.frame, result.pixels.bitmap, result.scale, result.width * result.height * 4, !result.standIn);
+                if (s.bounded)
+                    readinessDirty = true;
                 requestTick();
             }, (e) => {
-                if (!(e instanceof Cancelled) && session === s)
+                if (!(e instanceof Cancelled) && session === s) {
+                    s.blocked.add(want.frame);
                     report(message(e));
+                }
             });
         });
         // Files: what the next few seconds need, now; the rest of the film was asked for at load.
-        const window = Math.round(s.fps * Math.max(2, ahead * 2));
-        s.loader.want(s.needs.pathsIn(Math.max(0, transport.playhead - s.fps), transport.playhead + window), 0);
+        const window = Math.round(s.fps * Math.max(2, s.bounded ? options.mediaAhead ?? 15 : ahead * 2));
+        const paths = [...s.needs.pathsIn(Math.max(0, transport.playhead - s.fps), transport.playhead + window), ...s.needs.audioPathsIn(transport.playhead, transport.playhead + window + s.fps * 5)];
+        if (s.bounded) {
+            for (const [path, frame] of s.demand)
+                if (Math.abs(frame - transport.playhead) > s.fps * 5)
+                    s.demand.delete(path);
+            paths.push(...s.demand.keys());
+            paths.push(...s.requested.keys());
+            s.loader.retain(paths);
+        }
+        s.loader.want(paths, 0);
         if (playing)
             soundtrack?.prepare(transport.playhead);
     }
     /** What is ready now (cheap: one pass over the spans). */
     function readinessOf(s) {
-        const failed = s.source.assets.flatMap((a) => (s.loader.status(a.path) === "failed" ? [{ path: a.path, message: s.loader.error(a.path) ?? "failed" }] : []));
-        return { ranges: s.needs.readyRanges(s.loader.isReady), progress: s.loader.progress(), failed };
+        const failed = s.loader.failures();
+        // Dynamic scene video can choose arbitrary source times. Report cached exact frames
+        // conservatively until those dependencies have actually been evaluated.
+        return { ranges: s.dynamicVideo ? cache.exactRanges() : s.needs.readyRanges(s.loader.isReady), progress: s.loader.progress(s.bounded), failed, mediaBytes: s.loader.heldBytes };
     }
     /** Reports readiness while files arrive, a few times a second at most. */
     function reportReadiness(s, force = false) {
@@ -183,8 +214,8 @@ export function createPlayer(options) {
         const audible = clockKind === "audio";
         const result = transport.tick({
             now: now(), first, last,
-            showable: (f) => cache.has(f, scales.play),
-            canStart: (f) => bufferedAhead((g) => cache.scaleOf(g), f, last, scales.play) >= startBuffer(f, last, s.fps) && (!audible || (audioReady(s) && (soundtrack?.ready(f) ?? true))),
+            showable: (f) => cache.has(f, scales.play) && (!s.bounded || cache.get(f)?.exact === true),
+            canStart: (f) => bufferedAhead((g) => { const value = cache.get(g); return value && (value.exact || !s.bounded) ? value.scale : null; }, f, last, scales.play) >= startBuffer(f, last, s.fps) && (!audible || (audioReady(s) && (soundtrack?.ready(f) ?? true))),
         });
         if (result.started && audible)
             soundtrack?.start(result.frame, now());
@@ -218,8 +249,11 @@ export function createPlayer(options) {
         if (mine !== generation)
             throw new Cancelled();
         const doc = opened.doc;
-        const needs = FilmNeeds.of(doc, opened.assets.map((a) => a.path));
-        const loader = new AssetLoader(opened.assets, opened.fetchAsset);
+        const bounded = opened.assets.some((file) => file.url !== undefined);
+        const needs = FilmNeeds.of(doc, opened.assets.map((a) => a.path), { demandVideo: bounded });
+        const loader = new AssetLoader(opened.assets, opened.fetchAsset, 6, bounded ? options.mediaCacheBytes ?? 64 * 1024 * 1024 : Infinity);
+        loader.onEvict = (path) => pool.forget(path);
+        loader.onCancel = (path) => pool.mediaFailed(path, CANCELLED_PREVIEW);
         const previous = session;
         const carried = previous ? loader.carryOver(previous.loader) : [];
         const info = await pool.open(opened.manifest, opened.files).catch(async (e) => {
@@ -241,13 +275,21 @@ export function createPlayer(options) {
         transport.pause();
         transport = new Transport(doc.film.fps);
         soundtrack?.dispose();
-        soundtrack = new Soundtrack({ fps: doc.film.fps, length: doc.film.length, mix: (from, to) => pool.mix(from, to, 5) });
+        soundtrack = new Soundtrack({ fps: doc.film.fps, length: doc.film.length, ahead: bounded ? Math.max(1, Math.ceil((options.mediaAhead ?? 15) / 5)) : 3, mix: async (from, to, signal) => {
+                const s = session;
+                if (!s)
+                    throw new Cancelled();
+                await filesFor(s, s.needs.audioPathsIn(from, to), 1, signal);
+                return pool.mix(from, to, 5);
+            } });
         cache.clear();
         shownKey = "";
         shown = null;
         if (range && (range.from >= doc.film.length || range.to >= doc.film.length))
             range = null;
-        const s = { generation: mine, source: opened, needs, loader, film: { doc, build: opened.build, info }, fps: doc.film.fps, length: doc.film.length };
+        const videoScenes = new Set(doc.scenes.filter((scene) => scene.assets.some((asset) => asset.kind === "video")).map((scene) => scene.id));
+        const dynamicVideo = bounded && doc.tracks.some((track) => track.clips.some((clip) => clip.kind === "scene" && videoScenes.has(clip.scene)));
+        const s = { generation: mine, source: opened, needs, loader, bounded, dynamicVideo, blocked: new Set(), demand: new Map(), requested: new Map(), film: { doc, build: opened.build, info }, fps: doc.film.fps, length: doc.film.length };
         session = s;
         const deliver = (path) => deliverTo(s, path);
         for (const path of carried)
@@ -255,8 +297,12 @@ export function createPlayer(options) {
         loader.onChange((path) => {
             if (session !== s)
                 return;
-            if (loader.isReady(path))
+            if (loader.isReady(path)) {
+                s.blocked.clear();
                 deliver(path);
+            }
+            if (loader.status(path) === "failed")
+                pool.mediaFailed(path, loader.error(path) ?? "Media failed");
             readinessDirty = true;
             requestTick();
         });
@@ -268,8 +314,9 @@ export function createPlayer(options) {
             transport.play(0, s.length - 1);
         // The playhead's files first, then the rest of the film in the order it needs them.
         loader.want(needs.pathsAt(transport.playhead), 0);
-        for (const [path, at] of needs.firstNeeded())
-            loader.want([path], 10 + at / s.fps);
+        if (!bounded)
+            for (const [path, at] of needs.firstNeeded())
+                loader.want([path], 10 + at / s.fps);
         reportReadiness(s, true);
         emit("load", s.film);
         requestTick();
@@ -287,7 +334,7 @@ export function createPlayer(options) {
         if (data)
             pool.file(path, data, fileFor(path, audio));
         // Chunks mixed before an audio file arrived are silent where it plays: mix them again.
-        if (audio.has(path))
+        if (audio.has(path) && !s.bounded)
             soundtrack?.reset();
     }
     function resize(s) {
@@ -302,6 +349,8 @@ export function createPlayer(options) {
     /** Resolves once every file of `paths` is loaded; rejects with the first that failed, or with
      *  Cancelled when `signal` aborts first. */
     function filesFor(s, paths, priority, signal) {
+        for (const path of paths)
+            s.requested.set(path, (s.requested.get(path) ?? 0) + 1);
         s.loader.want(paths, priority);
         const failed = () => paths.find((p) => s.loader.status(p) === "failed");
         const done = () => failed() !== undefined || paths.every(s.loader.isReady);
@@ -329,9 +378,18 @@ export function createPlayer(options) {
                 settle(resolve, reject);
             });
             signal?.addEventListener("abort", abort, { once: true });
+        }).finally(() => {
+            for (const path of paths) {
+                const count = s.requested.get(path) ?? 0;
+                if (count <= 1)
+                    s.requested.delete(path);
+                else
+                    s.requested.set(path, count - 1);
+            }
         });
     }
     const player = {
+        retry() { reportedErrors.clear(); session?.blocked.clear(); session?.loader.retry(); requestTick(); },
         load,
         reload: () => {
             if (!lastSource)
@@ -345,7 +403,10 @@ export function createPlayer(options) {
                 return;
             }
             const { first, last } = bounds(s);
-            soundtrack?.stop();
+            if (s.bounded && Math.round(frame) !== transport.playhead)
+                soundtrack?.reset();
+            else
+                soundtrack?.stop();
             if (Math.round(frame) !== transport.playhead) {
                 movedBefore = movedAt;
                 movedAt = performance.now();
@@ -405,6 +466,10 @@ export function createPlayer(options) {
             const result = await pool.frame(f, Math.min(1, width / s.film.doc.film.width), { output: "bitmap", priority: 1000, signal });
             if (result.pixels.kind !== "bitmap")
                 throw new Error("The worker sent bytes for a preview.");
+            if (result.standIn) {
+                result.pixels.bitmap.close();
+                throw new Error("The requested video preview is unavailable.");
+            }
             return result.pixels.bitmap;
         },
         async pixels(frame, scale = 1) {
@@ -416,6 +481,8 @@ export function createPlayer(options) {
             const result = await pool.frame(f, scale, { output: "rgba", priority: 100 });
             if (result.pixels.kind !== "rgba")
                 throw new Error("The worker sent a bitmap for pixels.");
+            if (result.standIn)
+                throw new Error("The requested frame contains unavailable video.");
             return { width: result.width, height: result.height, rgba: result.pixels.rgba };
         },
         async mix(from, to) {
@@ -425,7 +492,7 @@ export function createPlayer(options) {
             const a = clampFrame(Math.min(from, to), 0, s.length), b = clampFrame(Math.max(from, to), 0, s.length);
             if (b <= a)
                 return { sampleRate: 48000, left: new Float32Array(0), right: new Float32Array(0) };
-            await filesFor(s, s.needs.audio, 1);
+            await filesFor(s, s.needs.audioPathsIn(from, to), 1);
             return pool.mix(a, b, 50);
         },
         on(event, listener) {

package/dist/player/pool.d.ts

@@ -46,6 +46,7 @@ export declare class WorkerPool {
     private opening;
     /** Called when a worker reports a failure that isn't a request's (a file it couldn't read). */
     onProblem: (message: string) => void;
+    onMediaNeed: (paths: ReadonlyArray<string>) => void;
     constructor(options: PoolOptions);
     get size(): number;
     /** Opens a build in every worker (dropping whatever was asked of the last one); resolves once all have. */
@@ -53,6 +54,8 @@ export declare class WorkerPool {
     /** Sends an imported file to the workers it is for: audio to the soundtrack's worker only
      *  (decoded there), proxy segments to the video worker. */
     file(path: string, bytes: Uint8Array, to: FileFor): void;
+    forget(path: string): void;
+    mediaFailed(path: string, message: string): void;
     /** Draws a frame. Rejects with Cancelled if it is dropped (or its signal aborts) before a worker takes it. */
     frame(frame: number, scale: number, request: FrameRequest): Promise<FrameResult>;
     /** Mixes the soundtrack between two frames (on the soundtrack's worker). */

package/dist/player/pool.js

@@ -1,4 +1,4 @@
-import { parseFromWorker } from "./protocol.js";
+import { parseFromWorker, parseMediaNeed } from "./protocol.js";
 export class Cancelled extends Error {
     name = "Cancelled";
     constructor() {
@@ -13,11 +13,14 @@ export class WorkerPool {
     opening = null;
     /** Called when a worker reports a failure that isn't a request's (a file it couldn't read). */
     onProblem = () => { };
+    onMediaNeed = () => { };
     constructor(options) {
         const videoWorker = new Worker(options.workerUrl, { type: "module" });
         const videoChannel = new MessageChannel();
         videoWorker.postMessage({ role: "video" }, [videoChannel.port2]);
         this.video = { worker: videoWorker, port: videoChannel.port1 };
+        this.video.port.onmessage = (event) => { const paths = parseMediaNeed(event.data); if (paths)
+            this.onMediaNeed(paths); };
         this.slots = Array.from({ length: Math.max(1, options.workers) }, () => {
             const worker = new Worker(options.workerUrl, { type: "module" });
             const channel = new MessageChannel();
@@ -70,6 +73,12 @@ export class WorkerPool {
             for (const slot of this.slots)
                 this.post(slot, { kind: "file", path, bytes, audio: false });
     }
+    forget(path) {
+        this.video.port.postMessage({ kind: "forget", path });
+        for (const slot of this.slots)
+            this.post(slot, { kind: "forget", path });
+    }
+    mediaFailed(path, message) { this.video.port.postMessage({ kind: "failure", path, message }); }
     /** Draws a frame. Rejects with Cancelled if it is dropped (or its signal aborts) before a worker takes it. */
     frame(frame, scale, request) {
         return new Promise((resolve, reject) => this.enqueue({ kind: "frame", frame, scale, output: request.output, playback: request.playback ?? false, resolve }, request.priority, reject, request.signal));
@@ -184,7 +193,7 @@ export class WorkerPool {
                     break;
                 }
                 if (slot.current?.id === msg.id) {
-                    slot.current.reject(new Error(msg.message));
+                    slot.current.reject(msg.cancelled ? new Cancelled() : new Error(msg.message));
                     slot.current = null;
                 }
                 break;

package/dist/player/protocol.d.ts

@@ -4,6 +4,9 @@ export type Role = "frames" | "video";
 export declare function parseRole(data: unknown): Role | null;
 export type FrameOutput = "bitmap" | "rgba";
 export type ToWorker = {
+    readonly kind: "forget";
+    readonly path: string;
+} | {
     readonly kind: "open";
     readonly manifest: string;
     readonly files: Readonly<Record<string, string>>;
@@ -58,12 +61,23 @@ export type FromWorker = {
     readonly kind: "error";
     readonly id: number | null;
     readonly message: string;
+    readonly cancelled?: boolean;
 };
+export declare const CANCELLED_PREVIEW = "The preview was superseded by a seek.";
+export declare class MediaCancelled extends Error {
+}
 export declare function parseToWorker(data: unknown): ToWorker | null;
 /** A plan summary (summarizePlan in @tongue-core/film), checked field by field. */
 export declare function parsePlanSummary(v: unknown): PlanSummary | null;
 export declare function parseFromWorker(data: unknown): FromWorker | null;
 export type ToVideo = {
+    readonly kind: "failure";
+    readonly path: string;
+    readonly message: string;
+} | {
+    readonly kind: "forget";
+    readonly path: string;
+} | {
     readonly kind: "file";
     readonly path: string;
     readonly bytes: Uint8Array;
@@ -75,6 +89,7 @@ export type ToVideo = {
     readonly kind: "client";
 };
 export declare function parseToVideo(data: unknown): ToVideo | null;
+export declare function parseMediaNeed(data: unknown): ReadonlyArray<string> | null;
 /** A frame of a video, by the video's name and its own frame numbering. */
 export interface VideoFrameWant {
     readonly video: string;

package/dist/player/protocol.js

@@ -2,6 +2,9 @@
 export function parseRole(data) {
     return isRecord(data) && (data["role"] === "frames" || data["role"] === "video") ? data["role"] : null;
 }
+export const CANCELLED_PREVIEW = "The preview was superseded by a seek.";
+export class MediaCancelled extends Error {
+}
 const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isNumber = (v) => typeof v === "number" && Number.isFinite(v);
 const isString = (v) => typeof v === "string";
@@ -22,6 +25,7 @@ export function parseToWorker(data) {
     if (!isRecord(data))
         return null;
     switch (data["kind"]) {
+        case "forget": return isString(data["path"]) ? { kind: "forget", path: data["path"] } : null;
         case "open": {
             const manifest = data["manifest"], files = textFiles(data["files"]);
             return isString(manifest) && files ? { kind: "open", manifest, files } : null;
@@ -131,7 +135,7 @@ export function parseFromWorker(data) {
         }
         case "error": {
             const id = data["id"], message = data["message"];
-            return { kind: "error", id: isNumber(id) ? id : null, message: isString(message) ? message : "unknown error" };
+            return { kind: "error", id: isNumber(id) ? id : null, message: isString(message) ? message : "unknown error", ...(data["cancelled"] === true ? { cancelled: true } : {}) };
         }
         default:
             return null;
@@ -141,6 +145,8 @@ export function parseToVideo(data) {
     if (!isRecord(data))
         return null;
     switch (data["kind"]) {
+        case "failure": return isString(data["path"]) && isString(data["message"]) ? { kind: "failure", path: data["path"], message: data["message"] } : null;
+        case "forget": return isString(data["path"]) ? { kind: "forget", path: data["path"] } : null;
         case "file": {
             const path = data["path"], bytes = data["bytes"];
             return isString(path) && bytes instanceof Uint8Array ? { kind: "file", path, bytes } : null;
@@ -153,6 +159,11 @@ export function parseToVideo(data) {
             return null;
     }
 }
+export function parseMediaNeed(data) {
+    if (!isRecord(data) || data["kind"] !== "need")
+        return null;
+    return listOf(data["paths"], (value) => isString(value) ? value : null);
+}
 function parseWant(v) {
     if (!isRecord(v))
         return null;

package/dist/player/source.d.ts

@@ -1,14 +1,15 @@
 import { type BuildDoc, type FilmDoc } from "@tongue-core/project/doc";
 import type { AssetFileInfo, FetchBytes } from "./assets.js";
+import { type MediaRequestOptions } from "@tongue-core/project/media";
 /** A build served as files: its folder's URL. */
-export interface BuildSource {
+export interface BuildSource extends MediaRequestOptions {
     /** The build's folder (where build.json is), absolute or relative to the page. */
     readonly build: string | URL;
     /** Another manifest in the build, such as one scene on its own. Default build.json. */
     readonly manifest?: string;
 }
 /** A build read a file at a time, from wherever it is kept: a Git commit, memory, an archive. */
-export interface FileSource {
+export interface FileSource extends MediaRequestOptions {
     /** One file of the build, by its path in the build as build.json and film.json give it:
      *  `build.json`, `film.json`, `scenes/title.5ebf1e9a05d5.js`, `assets/fonts/inter.ttf`.
      *  Rejects when the file can't be read. */

package/dist/player/source.js

@@ -1,5 +1,6 @@
 import { parseBuildDoc, parseFilmDoc } from "@tongue-core/project/doc";
-import { Effect } from "effect";
+import { Cause, Effect, Exit } from "effect";
+import { readMedia } from "@tongue-core/project/media";
 export class SourceError extends Error {
     name = "SourceError";
 }
@@ -22,7 +23,7 @@ async function fetchOk(url, signal) {
 const message = (e) => (e instanceof Error ? e.message : String(e));
 const failure = (e) => new SourceError(message(e));
 /** Opens a build: its manifest and film.json, then every scene bundle at once. */
-async function open(manifest, reader) {
+async function open(manifest, reader, options = {}) {
     const buildText = await reader.text(manifest);
     const build = await Effect.runPromise(parseBuildDoc(buildText)).catch((e) => { throw failure(e); });
     const filmText = await reader.text(build.film);
@@ -31,7 +32,18 @@ async function open(manifest, reader) {
     const files = { [manifest]: buildText, [build.film]: filmText };
     for (const [path, code] of bundles)
         files[path] = code;
-    return { manifest, build, doc, files, assets: build.assets.files, fetchAsset: reader.assets(build.assets.dir) };
+    const local = reader.assets(build.assets.dir);
+    const locations = new Map(build.assets.files.map((file) => [file.path, file.url]));
+    const fetchAsset = async (path, signal) => {
+        const url = locations.get(path);
+        if (url === undefined)
+            return local(path, signal);
+        const result = await Effect.runPromiseExit(readMedia(path, url, async (response) => new Uint8Array(await response.arrayBuffer()), options), { signal });
+        if (Exit.isSuccess(result))
+            return result.value;
+        throw Cause.squash(result.cause);
+    };
+    return { manifest, build, doc, files, assets: build.assets.files, fetchAsset };
 }
 /** Opens a build served as files: every path resolved against its folder's URL. */
 export async function openSource(source, page, signal) {
@@ -42,7 +54,7 @@ export async function openSource(source, page, signal) {
             const assetsBase = buildBase(dir, base.href);
             return async (path, abort) => new Uint8Array(await (await fetchOk(new URL(path, assetsBase), abort)).arrayBuffer());
         },
-    });
+    }, source);
     return { ...opened, base };
 }
 /** A file in one of the build's folders: "assets" and "fonts/inter.ttf" → "assets/fonts/inter.ttf". */
@@ -59,7 +71,7 @@ export async function openFiles(source, signal) {
     return open(source.manifest ?? "build.json", {
         text: async (path) => utf8.decode(await bytes(path, signal)),
         assets: (dir) => (path, abort) => bytes(inFolder(dir, path), abort),
-    });
+    }, source);
 }
 /** Opens either kind of source; a served build's folder is resolved against `page`. */
 export function openFilm(source, page, signal) {

package/dist/player/video.d.ts

@@ -10,11 +10,15 @@ export declare class VideoError extends Error {
 }
 /** Every video's proxy, by name. Files arrive from the player: info.json first, then segments. */
 export declare class ProxyVideos {
+    private readonly need;
+    constructor(need?: (path: string) => void);
     private readonly videos;
     private readonly early;
     /** Takes a file the player sent: a video's info.json (with its proxy facts) or a segment. */
     file(path: string, bytes: Uint8Array, proxyOf: (bytes: Uint8Array) => ProxyInfo | null): void;
     has(name: string): boolean;
+    forget(path: string): void;
+    fail(path: string, message: string): void;
     frame(name: string, index: number): Promise<DecodedFrame>;
     reset(): void;
 }

package/dist/player/video.js

@@ -1,4 +1,5 @@
 import { demuxMp4, encodeQoi, sampleData, writeYuvHeader, YUV_HEADER, yuvImageLayout, yuvSize } from "@tongue-core/engine";
+import { CANCELLED_PREVIEW } from "./protocol.js";
 /** Bytes of decoded frames kept per video (about a dozen 720p frames). */
 const RING_BYTES = 48 * 1024 * 1024;
 /** Decode on from the last frame, rather than from a keyframe, when the next is this close ahead. */
@@ -8,7 +9,7 @@ const FORWARD = 45;
  *  the frame itself is kept: the ones before it would only delay it. */
 const KEEP_BEHIND = 8;
 /** How long to wait for a segment the player hasn't sent yet, and for a frame to come out. */
-const SEGMENT_WAIT_MS = 5000;
+const SEGMENT_WAIT_MS = 120_000;
 const OUTPUT_WAIT_MS = 40;
 export class VideoError extends Error {
     name = "VideoError";
@@ -34,6 +35,8 @@ async function imageOf(frame) {
 class ProxyVideo {
     name;
     info;
+    need;
+    failures = new Map();
     segments = new Map();
     demuxed = new Map();
     arrivals = new Map();
@@ -48,18 +51,49 @@ class ProxyVideo {
     waiting = new Map();
     queue = Promise.resolve();
     total;
-    constructor(name, info) {
+    constructor(name, info, need) {
         this.name = name;
         this.info = info;
+        this.need = need;
         const last = info.segments[info.segments.length - 1];
         this.total = last ? last.first + last.frames : 0;
     }
     addSegment(index, bytes) {
+        this.failures.delete(index);
         this.segments.set(index, bytes);
         for (const arrived of this.arrivals.get(index) ?? [])
             arrived();
         this.arrivals.delete(index);
     }
+    fail(index, message) {
+        this.failures.set(index, message);
+        for (const arrived of this.arrivals.get(index) ?? [])
+            arrived();
+        this.arrivals.delete(index);
+    }
+    forget(index) {
+        this.segments.delete(index);
+        this.demuxed.delete(index);
+        const segment = this.info.segments[index];
+        if (segment)
+            for (const [frame, data] of this.ring)
+                if (frame >= segment.first && frame < segment.first + segment.frames) {
+                    this.ring.delete(frame);
+                    this.ringBytes -= data.image.length;
+                }
+        if (this.segments.size === 0)
+            this.closeDecoder();
+    }
+    get bytes() { return this.ringBytes; }
+    trim(bytes) {
+        while (this.ringBytes > bytes && this.ring.size > 0) {
+            const first = this.ring.entries().next();
+            if (first.done)
+                break;
+            this.ring.delete(first.value[0]);
+            this.ringBytes -= first.value[1].image.length;
+        }
+    }
     /** A frame by the video's own numbering (clamped to the proxy's frames). Requests run one at a time. */
     frame(index) {
         const job = this.queue.then(() => this.decodeTo(Math.max(0, Math.min(this.total - 1, Math.round(index)))));
@@ -67,9 +101,20 @@ class ProxyVideo {
         return job;
     }
     close() {
+        this.closeDecoder();
+        for (const [index, listeners] of this.arrivals) {
+            this.failures.set(index, CANCELLED_PREVIEW);
+            for (const arrived of listeners)
+                arrived();
+        }
+        this.arrivals.clear();
+    }
+    closeDecoder() {
         if (this.decoder && this.decoder.state !== "closed")
             this.decoder.close();
         this.decoder = null;
+        this.next = -1;
+        this.keep.clear();
         for (const list of this.waiting.values())
             for (const w of list)
                 w(null);
@@ -91,14 +136,23 @@ class ProxyVideo {
         let bytes = this.segments.get(k);
         if (!bytes) {
             await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new VideoError(`video "${this.name}": proxy segment ${k} never arrived`)), SEGMENT_WAIT_MS);
+                const arrived = () => { clearTimeout(timer); resolve(); };
+                const timer = setTimeout(() => {
+                    const pending = this.arrivals.get(k)?.filter((listener) => listener !== arrived) ?? [];
+                    if (pending.length === 0)
+                        this.arrivals.delete(k);
+                    else
+                        this.arrivals.set(k, pending);
+                    reject(new VideoError(`video "${this.name}": proxy segment ${k} never arrived`));
+                }, SEGMENT_WAIT_MS);
                 const list = this.arrivals.get(k) ?? [];
-                list.push(() => { clearTimeout(timer); resolve(); });
+                list.push(arrived);
                 this.arrivals.set(k, list);
+                this.need(`video/${this.name}/proxy/${String(k).padStart(5, "0")}.mp4`);
             });
             bytes = this.segments.get(k);
             if (!bytes)
-                throw new VideoError(`video "${this.name}": proxy segment ${k} is missing`);
+                throw new VideoError(this.failures.get(k) ?? `video "${this.name}": proxy segment ${k} is missing`);
         }
         let video = this.demuxed.get(k);
         if (!video) {
@@ -205,12 +259,16 @@ class ProxyVideo {
         const decoded = await result;
         clearTimeout(timer);
         if (!decoded)
-            throw new VideoError(`video "${this.name}": frame ${index} didn't decode`);
+            throw new VideoError(decoder.state === "closed" ? CANCELLED_PREVIEW : `video "${this.name}": frame ${index} didn't decode`);
         return decoded;
     }
 }
 /** Every video's proxy, by name. Files arrive from the player: info.json first, then segments. */
 export class ProxyVideos {
+    need;
+    constructor(need = () => { }) {
+        this.need = need;
+    }
     videos = new Map();
     early = new Map();
     /** Takes a file the player sent: a video's info.json (with its proxy facts) or a segment. */
@@ -221,7 +279,7 @@ export class ProxyVideos {
             if (!proxy)
                 return;
             this.videos.get(info[1])?.close();
-            const video = new ProxyVideo(info[1], proxy);
+            const video = new ProxyVideo(info[1], proxy, this.need);
             this.videos.set(info[1], video);
             for (const [k, segment] of this.early.get(info[1]) ?? [])
                 video.addSegment(k, segment);
@@ -244,11 +302,34 @@ export class ProxyVideos {
     has(name) {
         return this.videos.has(name);
     }
-    frame(name, index) {
+    forget(path) {
+        const match = /^video\/([^/]+)\/proxy\/(\d+)\.mp4$/.exec(path);
+        if (match?.[1] !== undefined) {
+            this.videos.get(match[1])?.forget(Number(match[2]));
+            this.early.get(match[1])?.delete(Number(match[2]));
+        }
+    }
+    fail(path, message) {
+        const match = /^video\/([^/]+)\/proxy\/(\d+)\.mp4$/.exec(path);
+        if (match?.[1] !== undefined)
+            this.videos.get(match[1])?.fail(Number(match[2]), message);
+    }
+    async frame(name, index) {
         const video = this.videos.get(name);
         if (!video)
             return Promise.reject(new VideoError(`video "${name}" has no proxy here`));
-        return video.frame(index);
+        const frame = await video.frame(index);
+        let bytes = [...this.videos.values()].reduce((total, item) => total + item.bytes, 0);
+        for (const item of this.videos.values()) {
+            if (bytes <= 64 * 1024 * 1024)
+                break;
+            if (item === video)
+                continue;
+            const held = item.bytes;
+            item.trim(0);
+            bytes -= held;
+        }
+        return frame;
     }
     reset() {
         for (const v of this.videos.values())