@axium/kino 0.0.1

package/dist/server/api/upload.js

@@ -0,0 +1,122 @@
+import { getConfig } from '@axium/core';
+import { requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { error, json, parseBody, withError } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import { UploadManager } from '@axium/server/uploads';
+import * as kt from 'kinotool';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { omit, pick } from 'utilium';
+import { KinoMovieUploadInit, KinoTvUploadInit } from '../../common.js';
+import { getEpisode, getMovie } from '../db.js';
+import { applyMetadata, episodePath, extensionForType, moviePath, remuxUpload } from '../media.js';
+import { tmdb } from '../tmdb.js';
+import { ID } from './metadata.js';
+const movieUploads = new UploadManager(() => getConfig('@axium/kino').upload);
+addRoute({
+    path: '/api/kino/movies/upload',
+    async PUT(request) {
+        const session = await requireSession(request);
+        const { allow_user_uploads } = getConfig('@axium/kino');
+        if (!allow_user_uploads && !session.user.isAdmin)
+            error(403, 'Only administrators are allowed to upload movies');
+        const init = await parseBody(request, KinoMovieUploadInit);
+        if (!extensionForType(init.type))
+            error(415, 'Only mkv and mp4 files are supported');
+        let movie, id = init.id;
+        if (!id) {
+            const { title, year } = kt.parseTitle(init.name);
+            const { results: [movieInit], } = await tmdb().search.movies({ query: title, year, include_adult: true });
+            if (!movieInit)
+                error(406, 'Could not determine a matching movie');
+            movie = kt.Movie.parse(movieInit);
+            id = movie.id;
+        }
+        movie ||= await getMovie(id);
+        const existing = await database.selectFrom('kino_movie_uploads').where('id', '=', id).executeTakeFirst();
+        if (existing)
+            error(409, 'Movie already uploaded');
+        return json({
+            max_transfer_size: 100,
+            movie,
+            token: movieUploads.start(init, session, movie),
+        }, { status: 202 });
+    },
+});
+movieUploads.addEndpoint('/raw/kino/movies/upload', async (upload) => {
+    const base = moviePath(upload.data.id);
+    const ext = extensionForType(upload.init.type); // already checked when the upload was started
+    const tx = await database.startTransaction().execute();
+    try {
+        mkdirSync(dirname(base), { recursive: true });
+        const item = await tx
+            .insertInto('kino_movie_uploads')
+            .values({ ...upload.init, id: upload.data.id, hash: upload.hash })
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        upload.writeTo(base + ext);
+        await applyMetadata(base + ext, ext, upload.data);
+        await tx.commit().execute();
+        // Runs in the background; until it finishes the original is served
+        remuxUpload(base);
+        return item;
+    }
+    catch (error) {
+        await tx.rollback().execute();
+        throw withError('Could not upload movie', 500)(error);
+    }
+});
+const tvUploads = new UploadManager(() => getConfig('@axium/kino').upload);
+addRoute({
+    path: '/api/kino/tv/:id/upload',
+    params: { id: ID },
+    async PUT(request, { id }) {
+        const session = await requireSession(request);
+        const { allow_user_uploads } = getConfig('@axium/kino');
+        if (!allow_user_uploads && !session.user.isAdmin)
+            error(403, 'Only administrators are allowed to upload TV shows');
+        const init = await parseBody(request, KinoTvUploadInit);
+        if (!extensionForType(init.type))
+            error(415, 'Only mkv and mp4 files are supported');
+        const episode = await getEpisode(id, init.season, init.episode);
+        const existing = await database
+            .selectFrom('kino_tv_uploads')
+            .where(eb => eb.and({ id, season_number: init.season, episode_number: init.episode }))
+            .executeTakeFirst();
+        if (existing)
+            error(409, 'TV episode already uploaded');
+        return json({
+            max_transfer_size: 100,
+            episode,
+            token: tvUploads.start(init, session, episode),
+        }, { status: 202 });
+    },
+});
+tvUploads.addEndpoint('/raw/kino/tv/:id/upload', async (upload) => {
+    const { id, season_number, episode_number } = upload.data;
+    const base = episodePath(id, season_number, episode_number);
+    const ext = extensionForType(upload.init.type);
+    const tx = await database.startTransaction().execute();
+    try {
+        const item = await tx
+            .insertInto('kino_tv_uploads')
+            .values({
+            ...omit(upload.init, 'season', 'episode'),
+            ...pick(upload.data, 'id', 'season_number', 'episode_number'),
+            hash: upload.hash,
+        })
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        mkdirSync(dirname(base), { recursive: true });
+        upload.writeTo(base + ext);
+        await applyMetadata(base + ext, ext, upload.data);
+        await tx.commit().execute();
+        remuxUpload(base);
+        return item;
+    }
+    catch (error) {
+        await tx.rollback().execute();
+        throw withError('Could not upload tv episode', 500)(error);
+    }
+});

package/dist/server/api/views.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/api/views.js

@@ -0,0 +1,128 @@
+import { requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { parseBody } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import { KinoViewInit } from '../../common.js';
+import { getEpisode, getMovie, getTv } from '../db.js';
+/** How many recently watched items the home page shows */
+const limit = 12;
+addRoute({
+    path: '/api/kino/views',
+    async GET(req) {
+        const { userId } = await requireSession(req);
+        /**
+         * Only cached rows are joined in — a recently watched list should never fan out into TMDB requests.
+         * Anything whose metadata has since been removed simply drops off the list.
+         */
+        const [movies, episodes] = await Promise.all([
+            database
+                .selectFrom('kino_movie_views')
+                .innerJoin('kino_movies', 'kino_movies.id', 'kino_movie_views.id')
+                .innerJoin('kino_movie_uploads', 'kino_movie_uploads.id', 'kino_movie_views.id')
+                .selectAll('kino_movies')
+                .select(['kino_movie_views.viewedAt', 'kino_movie_views.position', 'kino_movie_views.duration'])
+                .select(['kino_movie_uploads.uploadedAt', 'kino_movie_uploads.name as uploadName'])
+                .select(['kino_movie_uploads.size', 'kino_movie_uploads.type'])
+                .where('kino_movie_views.userId', '=', userId)
+                .orderBy('kino_movie_views.viewedAt', 'desc')
+                .limit(limit)
+                .execute(),
+            database
+                .selectFrom('kino_tv_views')
+                .innerJoin('kino_tv', 'kino_tv.id', 'kino_tv_views.id')
+                .innerJoin('kino_episodes', join => join
+                .onRef('kino_episodes.id', '=', 'kino_tv_views.id')
+                .onRef('kino_episodes.season_number', '=', 'kino_tv_views.season_number')
+                .onRef('kino_episodes.episode_number', '=', 'kino_tv_views.episode_number'))
+                .select(['kino_tv_views.viewedAt', 'kino_tv_views.position', 'kino_tv_views.duration'])
+                .select(eb => [
+                eb.ref('kino_episodes.season_number').as('season_number'),
+                eb.ref('kino_episodes.episode_number').as('episode_number'),
+                eb.ref('kino_episodes.name').as('episode_name'),
+                eb.ref('kino_episodes.air_date').as('air_date'),
+                eb.ref('kino_episodes.still_path').as('still_path'),
+            ])
+                .select(eb => [
+                eb.ref('kino_tv.id').as('showId'),
+                eb.ref('kino_tv.name').as('showName'),
+                eb.ref('kino_tv.overview').as('overview'),
+                eb.ref('kino_tv.first_air_date').as('first_air_date'),
+                eb.ref('kino_tv.adult').as('adult'),
+                eb.ref('kino_tv.poster_path').as('poster_path'),
+                eb.ref('kino_tv.backdrop_path').as('backdrop_path'),
+            ])
+                .where('kino_tv_views.userId', '=', userId)
+                .orderBy('kino_tv_views.viewedAt', 'desc')
+                .limit(limit)
+                .execute(),
+        ]);
+        const views = [
+            ...movies.map(({ viewedAt, position, duration, uploadedAt, uploadName, size, type, ...movie }) => ({
+                type: 'movie',
+                viewedAt,
+                position,
+                duration,
+                movie: { ...movie, upload: { uploadedAt, name: uploadName, size, type } },
+            })),
+            ...episodes.map(row => ({
+                type: 'tv',
+                viewedAt: row.viewedAt,
+                position: row.position,
+                duration: row.duration,
+                show: {
+                    id: row.showId,
+                    name: row.showName,
+                    overview: row.overview,
+                    first_air_date: row.first_air_date,
+                    adult: row.adult,
+                    poster_path: row.poster_path,
+                    backdrop_path: row.backdrop_path,
+                },
+                episode: {
+                    id: row.showId,
+                    season_number: row.season_number,
+                    episode_number: row.episode_number,
+                    name: row.episode_name,
+                    air_date: row.air_date,
+                    still_path: row.still_path,
+                },
+            })),
+        ];
+        // Both queries are capped at `limit`, so the merged list has to be trimmed again
+        return views.sort((a, b) => b.viewedAt.getTime() - a.viewedAt.getTime()).slice(0, limit);
+    },
+    async PUT(req) {
+        const { userId } = await requireSession(req);
+        const init = await parseBody(req, KinoViewInit);
+        const viewedAt = new Date();
+        const { position, duration } = init;
+        // The player sends this repeatedly while watching, so an existing row is updated in place
+        const progress = { viewedAt, position, duration: duration ?? null };
+        if (init.type == 'movie') {
+            const movie = await getMovie(init.id);
+            await database
+                .insertInto('kino_movie_views')
+                .values({ userId, id: init.id, ...progress })
+                .onConflict(b => b.columns(['userId', 'id']).doUpdateSet(progress))
+                .execute();
+            const upload = await database
+                .selectFrom('kino_movie_uploads')
+                .select(['uploadedAt', 'name', 'size', 'type'])
+                .where('id', '=', init.id)
+                .executeTakeFirst();
+            return { type: 'movie', ...progress, movie: { ...movie, upload } };
+        }
+        const [show, episode] = await Promise.all([getTv(init.id), getEpisode(init.id, init.season, init.episode)]);
+        await database
+            .insertInto('kino_tv_views')
+            .values({ userId, id: init.id, season_number: init.season, episode_number: init.episode, ...progress })
+            .onConflict(b => b.columns(['userId', 'id', 'season_number', 'episode_number']).doUpdateSet(progress))
+            .execute();
+        const upload = await database
+            .selectFrom('kino_tv_uploads')
+            .select(['uploadedAt', 'name', 'size', 'type'])
+            .where(eb => eb.and({ id: init.id, season_number: init.season, episode_number: init.episode }))
+            .executeTakeFirst();
+        return { type: 'tv', ...progress, show, episode: { ...episode, upload } };
+    },
+});

package/dist/server/db.d.ts

@@ -0,0 +1,11 @@
+import type { FromFile as FromSchemaFile } from '@axium/server/db/schema';
+import * as kt from 'kinotool';
+import type schema from '../../db.json';
+declare module '@axium/server/database' {
+    interface Schema extends FromSchemaFile<typeof schema> {
+    }
+}
+export declare function getMovie(id: number): Promise<kt.Movie>;
+export declare function getTv(id: number): Promise<kt.Tv>;
+export declare function getSeason(id: number, season_number: number): Promise<kt.Season>;
+export declare function getEpisode(id: number, season_number: number, episode_number: number): Promise<kt.Episode>;

package/dist/server/db.js

@@ -0,0 +1,100 @@
+import { database } from '@axium/server/database';
+import * as kt from 'kinotool';
+import { jsonArrayFrom } from 'kysely/helpers/postgres';
+import { omit } from 'utilium';
+import { tmdb } from './tmdb.js';
+export async function getMovie(id) {
+    const result = await database.selectFrom('kino_movies').where('id', '=', id).selectAll().executeTakeFirst();
+    if (result)
+        return result;
+    const movie = await tmdb().movies.details(id).then(kt.Movie.parse);
+    await database.insertInto('kino_movies').values(movie).returningAll().executeTakeFirstOrThrow();
+    return movie;
+}
+/** Seasons are stored in their own table, so pull them in alongside the show */
+function withSeasons(eb) {
+    return jsonArrayFrom(eb.selectFrom('kino_seasons').selectAll().whereRef('kino_seasons.id', '=', 'kino_tv.id').orderBy('kino_seasons.season_number'))
+        .$castTo()
+        .as('seasons');
+}
+/** Likewise for the episodes of a season */
+function withEpisodes(eb) {
+    return jsonArrayFrom(eb
+        .selectFrom('kino_episodes')
+        .selectAll()
+        .whereRef('kino_episodes.id', '=', 'kino_seasons.id')
+        .whereRef('kino_episodes.season_number', '=', 'kino_seasons.season_number')
+        .orderBy('kino_episodes.episode_number'))
+        .$castTo()
+        .as('episodes');
+}
+export async function getTv(id) {
+    const result = await database.selectFrom('kino_tv').where('id', '=', id).selectAll().select(withSeasons).executeTakeFirst();
+    // Search caches shows without their seasons, so a row on its own is not enough to skip TMDB
+    if (result?.seasons.length)
+        return result;
+    const tv = await tmdb().tvShows.details(id).then(kt.Tv.parse);
+    await database
+        .insertInto('kino_tv')
+        .values(omit(tv, 'seasons'))
+        .onConflict(b => b.doNothing())
+        .execute();
+    for (const season of tv.seasons || []) {
+        season.id = id;
+        await database
+            .insertInto('kino_seasons')
+            .values(omit(season, 'episodes'))
+            .onConflict(b => b.doNothing())
+            .execute();
+    }
+    return tv;
+}
+export async function getSeason(id, season_number) {
+    const result = await database
+        .selectFrom('kino_seasons')
+        .where(eb => eb.and({ id, season_number }))
+        .selectAll()
+        .select(withEpisodes)
+        .executeTakeFirst();
+    /**
+     * `getTv` inserts season rows without any episodes, so the row alone is not enough either.
+     * A season that genuinely has no episodes (e.g. one that has not aired) will re-check TMDB each time.
+     */
+    if (result?.episodes.length)
+        return result;
+    const season = await tmdb().tvSeasons.details({ tvShowID: id, seasonNumber: season_number }).then(kt.Season.parse);
+    season.id = id;
+    for (const episode of season.episodes || []) {
+        episode.id = id;
+        await database
+            .insertInto('kino_episodes')
+            .values(episode)
+            .onConflict(b => b.doNothing())
+            .execute();
+    }
+    await database
+        .insertInto('kino_seasons')
+        .values(omit(season, 'episodes'))
+        .onConflict(b => b.doNothing())
+        .execute();
+    return season;
+}
+export async function getEpisode(id, season_number, episode_number) {
+    const result = await database
+        .selectFrom('kino_episodes')
+        .where(eb => eb.and({ id, season_number, episode_number }))
+        .selectAll()
+        .executeTakeFirst();
+    if (result)
+        return result;
+    const episode = await tmdb()
+        .tvEpisode.details({ tvShowID: id, seasonNumber: season_number, episodeNumber: episode_number })
+        .then(kt.Episode.parse);
+    episode.id = id;
+    await database
+        .insertInto('kino_episodes')
+        .values(episode)
+        .onConflict(b => b.doNothing())
+        .execute();
+    return episode;
+}

package/dist/server/hooks.d.ts

@@ -0,0 +1,9 @@
+import '../common.js';
+import './api/metadata.js';
+import './api/raw.js';
+import './api/search.js';
+import './api/upload.js';
+import './api/views.js';
+import './images.js';
+export declare function load(): void;
+export declare function statusText(): Promise<string>;

package/dist/server/hooks.js

@@ -0,0 +1,19 @@
+import { getConfig } from '@axium/core';
+import { count } from '@axium/server/database';
+import { mkdirSync } from 'node:fs';
+import '../common.js';
+import './api/metadata.js';
+import './api/raw.js';
+import './api/search.js';
+import './api/upload.js';
+import './api/views.js';
+import './images.js';
+export function load() {
+    const { data_dir, images } = getConfig('@axium/kino');
+    mkdirSync(data_dir, { recursive: true });
+    mkdirSync(images.cache.directory, { recursive: true });
+}
+export async function statusText() {
+    const { kino_movie_uploads: movies, kino_tv_uploads: episodes } = await count('kino_movie_uploads', 'kino_tv_uploads');
+    return `${movies} movies and ${episodes} episodes`;
+}

package/dist/server/images.d.ts

@@ -0,0 +1,12 @@
+import { type ImageSize, type ImageType } from '../common.js';
+export declare function getCachePath(file: string, size: ImageSize): string;
+export declare function getCachedSizes(file: string, type?: ImageType | null): ImageSize[];
+export declare function removeFromCache(file: string, size: ImageSize): void;
+export type CacheEntry = [name: string, size: bigint, atime: bigint];
+/** Get all the files in the cache */
+export declare function getCacheFiles(): Generator<CacheEntry>;
+/** Compute cache size */
+export declare function computeCacheSize(files?: Iterable<CacheEntry>): bigint;
+/** The maximum cache size in bytes, or false when the cache is unlimited */
+export declare function maxCacheBytes(): bigint | false;
+export declare function pruneCache(): void;

package/dist/server/images.js

@@ -0,0 +1,152 @@
+import { getConfig } from '@axium/core';
+import { parseSearch } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import * as io from 'ioium/node';
+import mime from 'mime';
+import * as fs from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ImageFile, ImageSelection, imagesSizes, imageWidth } from '../common.js';
+export function getCachePath(file, size) {
+    const path = join(getConfig('@axium/kino').images.cache.directory, size, file);
+    fs.mkdirSync(dirname(path), { recursive: true });
+    return path;
+}
+export function getCachedSizes(file, type) {
+    const dir = getConfig('@axium/kino').images.cache.directory;
+    return imagesSizes[type || 'all'].filter(size => fs.existsSync(join(dir, size, file)));
+}
+let cacheSize;
+export function removeFromCache(file, size) {
+    cacheSize ??= computeCacheSize();
+    const path = getCachePath(file, size);
+    try {
+        const { size } = fs.statSync(path, { bigint: true });
+        fs.unlinkSync(path);
+        cacheSize -= size;
+    }
+    catch {
+        // ignore
+    }
+}
+/** Get all the files in the cache */
+export function* getCacheFiles() {
+    const { cache } = getConfig('@axium/kino').images;
+    for (const file of fs.readdirSync(cache.directory, { recursive: true, encoding: 'utf8' })) {
+        try {
+            const stats = fs.statSync(join(cache.directory, file), { bigint: true });
+            if (!stats.isFile())
+                continue;
+            yield [file, stats.size, stats.atimeMs];
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+/** Compute cache size */
+export function computeCacheSize(files = getCacheFiles()) {
+    let sum = 0n;
+    for (const [, size] of files)
+        sum += size;
+    return sum;
+}
+/** The maximum cache size in bytes, or false when the cache is unlimited */
+export function maxCacheBytes() {
+    const { max_size } = getConfig('@axium/kino').images.cache;
+    return max_size ? BigInt(Math.floor(max_size * 1024 * 1024)) : false;
+}
+export function pruneCache() {
+    const { cache } = getConfig('@axium/kino').images;
+    const max = maxCacheBytes();
+    if (!max)
+        return;
+    const files = Array.from(getCacheFiles());
+    cacheSize ??= computeCacheSize(files);
+    // Least recently used first, evicting the largest first when access times are equal
+    files.sort(([, sizeA, timeA], [, sizeB, timeB]) => Number(timeA - timeB || sizeB - sizeA));
+    for (const [file, size] of files) {
+        if (cacheSize < max)
+            return;
+        try {
+            fs.unlinkSync(join(cache.directory, file));
+        }
+        catch {
+            continue; // already gone; don't credit its size
+        }
+        cacheSize -= size;
+    }
+}
+addRoute({
+    path: '/raw/image/:file',
+    params: { file: ImageFile },
+    async GET(req, { file }) {
+        const selection = parseSearch(req, ImageSelection) || {};
+        const { base_url, cache } = getConfig('@axium/kino').images;
+        const size = selection.size || (selection.type && cache.max_image_sizes[selection.type]) || 'original', { type } = selection;
+        const tmdb = new URL(`${base_url}${size}/${file}`);
+        if (cache.mode == 'disabled')
+            return Response.redirect(tmdb);
+        const cachedSizes = getCachedSizes(file, type), cachedImages = cachedSizes.map(size => [size, imageWidth(size)]), cachedWidths = cachedImages.map(([, width]) => width);
+        const targetWidth = imageWidth(size);
+        const [closestCachedSize] = cachedImages.toSorted(([, a], [, b]) => Math.abs(a - targetWidth) - Math.abs(b - targetWidth))[0] || [];
+        const cachedImage = (size) => {
+            const headers = {
+                'x-is-cached': '1',
+                'Cache-Control': 'public, max-age=31536000, immutable',
+            };
+            const type = mime.getType(getCachePath(file, size));
+            if (type)
+                headers['Content-Type'] = type;
+            return new Response(fs.readFileSync(getCachePath(file, size)), { headers });
+        };
+        const fetchImage = async () => {
+            const res = await fetch(tmdb, {
+                signal: AbortSignal.timeout(5000),
+            }).catch(() => null);
+            if (!res?.ok || !res.body) {
+                if (res?.status === 404)
+                    return new Response(null, { status: 404 });
+                io.warnOnce('Kino: using fallback images because TMDB is unavailable');
+                if (!closestCachedSize)
+                    return new Response('TMDB is unavailable and no sizes of this image are cached', { status: 503 });
+                return cachedImage(closestCachedSize);
+            }
+            if ((cache.largest_only && cachedWidths.some(w => w >= targetWidth)) || cachedSizes.includes(size))
+                return res;
+            const data = await res.bytes();
+            try {
+                fs.writeFileSync(getCachePath(file, size), data);
+                cacheSize ??= computeCacheSize();
+                if (cache.largest_only)
+                    for (const cachedSize of cachedSizes)
+                        removeFromCache(file, cachedSize);
+                cacheSize += BigInt(data.byteLength);
+                const max = maxCacheBytes();
+                if (max && cacheSize > max)
+                    pruneCache();
+            }
+            catch (e) {
+                io.warn('Kino: failed to cache image: ' + io.errorText(e));
+            }
+            const headers = { 'Cache-Control': 'public, max-age=31536000, immutable' };
+            const contentType = res.headers.get('Content-Type');
+            if (contentType)
+                headers['Content-Type'] = contentType;
+            return new Response(data, { headers });
+        };
+        switch (cache.mode) {
+            case 'fallback':
+                return fetchImage();
+            case 'exact-size':
+                return cachedSizes.includes(size) ? cachedImage(size) : await fetchImage();
+            case 'quality': {
+                const [nearestBigSize] = cachedImages.filter(([, w]) => w >= targetWidth).sort(([, a], [, b]) => a - b)[0] || [];
+                if (nearestBigSize)
+                    return cachedImage(nearestBigSize);
+                return await fetchImage();
+            }
+            case 'prefer':
+                return closestCachedSize ? cachedImage(closestCachedSize) : await fetchImage();
+        }
+    },
+});

package/dist/server/media.d.ts

@@ -0,0 +1,47 @@
+import * as kt from 'kinotool';
+import { type MediaExt } from '../common.js';
+export { extensionForType, mediaExtensions, mediaTypes, type MediaExt } from '../common.js';
+/** Path of a movie's files, without an extension */
+export declare function moviePath(id: number): string;
+/** Path of an episode's files, without an extension */
+export declare function episodePath(id: number, season: number, episode: number): string;
+export interface ResolvedMedia {
+    path: string;
+    ext: MediaExt;
+    type: string;
+}
+/**
+ * Pick which of an item's files to serve.
+ *
+ * This deliberately ignores the `remux` config: it can be changed at any time, and files written under
+ * an older setting still have to be served. Only what is actually on disk decides.
+ *
+ * Playback prefers the MP4, since browsers can seek it without reading the whole file.
+ * Downloads prefer the original upload, which still has every audio track and subtitle.
+ */
+export declare function resolveMedia(base: string, download?: boolean): ResolvedMedia | null;
+/** Every file belonging to an item, including a partial remux left behind by a crash */
+export declare function mediaFiles(base: string): string[];
+/** Remove all of an item's files. Returns the paths that were removed. */
+export declare function removeMedia(base: string): string[];
+/**
+ * Start remuxing a freshly uploaded MKV to MP4, if the config asks for it.
+ *
+ * Remuxing multi-GB files takes minutes, so ffmpeg is spawned rather than run through
+ * `kt.mkv.remuxToMp4`, whose synchronous `trackCommand` would block the event loop for the duration.
+ * Until it finishes, `resolveMedia` keeps serving the MKV.
+ */
+export declare function remuxUpload(base: string): void;
+/**
+ * Apply TMDB metadata to a freshly written file.
+ *
+ * Only Matroska is handled: `mkvpropedit` edits the header in place, so it finishes in milliseconds
+ * regardless of file size. `kt.mp4.setFromMovie` would rewrite the entire container, and it runs
+ * synchronously, so calling it here would block the event loop for as long as the copy takes.
+ *
+ * A remuxed MP4 still picks up the title through the remux's `-map_metadata`.
+ *
+ * @todo Tag directly-uploaded MP4s once kinotool can plan the rewrite the way `planRemuxToMp4` does,
+ * so ffmpeg can be spawned instead of run inline.
+ */
+export declare function applyMetadata(path: string, ext: MediaExt, data: kt.Movie | kt.Episode): Promise<void>;