jukebox-media-server 0.2.0 → 0.4.0

package/dist/server/index.js

@@ -1,17 +1,21 @@
-import { createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
-import path, { basename, extname, join } from "path";
+import { constants, createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
+import path, { basename, dirname, extname, join } from "path";
 import { fileURLToPath } from "url";
 import { createServer } from "http";
-import { Http2ServerRequest, constants } from "http2";
+import { Http2ServerRequest, constants as constants$1 } from "http2";
 import { Readable } from "stream";
 import crypto$1, { randomBytes, scrypt, timingSafeEqual } from "crypto";
 import { versions } from "process";
 import Database from "better-sqlite3";
 import crypto$2 from "node:crypto";
 import fs from "node:fs";
-import { readdir, stat, writeFile } from "fs/promises";
 import os, { homedir } from "os";
 import { promisify } from "util";
+import { access, readFile, readdir, stat } from "fs/promises";
+import { EventEmitter } from "node:events";
+import process$1 from "node:process";
+import os$1 from "node:os";
+import tty from "node:tty";
 import { spawn } from "child_process";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -341,7 +345,7 @@ var drainIncoming = (incoming) => {
 	incomingWithDrainState[incomingDraining] = true;
 	if (incoming instanceof Http2ServerRequest) {
 		try {
-			incoming.stream?.close?.(constants.NGHTTP2_NO_ERROR);
+			incoming.stream?.close?.(constants$1.NGHTTP2_NO_ERROR);
 		} catch {}
 		return;
 	}
@@ -2518,17 +2522,17 @@ var colorStatus = async (status) => {
 	}
 	return `${status}`;
 };
-async function log(fn, prefix, method, path, status = 0, elapsed) {
+async function log$1(fn, prefix, method, path, status = 0, elapsed) {
 	fn(prefix === "<--" ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`);
 }
 var logger$1 = (fn = console.log) => {
 	return async function logger2(c, next) {
 		const { method, url } = c.req;
 		const path = url.slice(url.indexOf("/", 8));
-		await log(fn, "<--", method, path);
+		await log$1(fn, "<--", method, path);
 		const start = Date.now();
 		await next();
-		await log(fn, "-->", method, path, c.res.status, time(start));
+		await log$1(fn, "-->", method, path, c.res.status, time(start));
 	};
 };
 //#endregion
@@ -6785,24 +6789,11 @@ function migrate(db, config) {
 //#endregion
 //#region src/config/index.ts
 const configDirectory = join(homedir(), ".jukebox");
-const configFilePath = join(configDirectory, "config.json");
+join(configDirectory, "config.json");
 const databasePath = join(configDirectory, "jukebox.db");
 function ensureConfigDirectory() {
 	mkdirSync(configDirectory, { recursive: true });
 }
-function getConfig() {
-	if (!existsSync(configFilePath)) return null;
-	try {
-		const raw = readFileSync(configFilePath, "utf-8");
-		return JSON.parse(raw);
-	} catch {
-		return null;
-	}
-}
-async function saveConfig(config) {
-	ensureConfigDirectory();
-	await writeFile(configFilePath, JSON.stringify(config, null, 2));
-}
 //#endregion
 //#region src/database/schema.ts
 var schema_exports = /* @__PURE__ */ __exportAll({
@@ -6812,9 +6803,12 @@ var schema_exports = /* @__PURE__ */ __exportAll({
 	libraries: () => libraries,
 	movies: () => movies,
 	profiles: () => profiles,
+	scanJobs: () => scanJobs,
 	seasons: () => seasons,
 	sessions: () => sessions$1,
+	settings: () => settings,
 	shows: () => shows,
+	subtitles: () => subtitles,
 	watchProgress: () => watchProgress
 });
 const profiles = sqliteTable("profiles", {
@@ -6839,27 +6833,27 @@ const movies = sqliteTable("movies", {
 	extension: text("extension"),
 	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
-	tmdbId: integer("tmdb_id"),
+	externalId: text("external_id"),
 	year: integer("year"),
 	overview: text("overview"),
 	runtime: integer("runtime"),
 	genres: text("genres"),
 	rating: real("rating"),
-	posterPath: text("poster_path"),
-	backdropPath: text("backdrop_path"),
+	posterUrl: text("poster_url"),
+	backdropUrl: text("backdrop_url"),
 	trailerUrl: text("trailer_url")
 });
 const shows = sqliteTable("shows", {
 	id: integer("id").primaryKey({ autoIncrement: true }),
 	title: text("title").notNull(),
 	folderPath: text("folder_path").notNull().unique(),
-	tmdbId: integer("tmdb_id"),
+	externalId: text("external_id"),
 	year: integer("year"),
 	overview: text("overview"),
 	genres: text("genres"),
 	rating: real("rating"),
-	posterPath: text("poster_path"),
-	backdropPath: text("backdrop_path"),
+	posterUrl: text("poster_url"),
+	backdropUrl: text("backdrop_url"),
 	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
 });
@@ -6869,7 +6863,7 @@ const seasons = sqliteTable("seasons", {
 	seasonNumber: integer("season_number").notNull(),
 	name: text("name"),
 	overview: text("overview"),
-	posterPath: text("poster_path"),
+	posterUrl: text("poster_url"),
 	episodeCount: integer("episode_count")
 });
 const episodes = sqliteTable("episodes", {
@@ -6883,18 +6877,18 @@ const episodes = sqliteTable("episodes", {
 	fileName: text("file_name").notNull(),
 	fileSize: integer("file_size"),
 	extension: text("extension"),
-	tmdbId: integer("tmdb_id"),
+	externalId: text("external_id"),
 	overview: text("overview"),
 	runtime: integer("runtime"),
-	stillPath: text("still_path"),
+	stillUrl: text("still_url"),
 	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
 });
 const watchProgress = sqliteTable("watch_progress", {
 	id: integer("id").primaryKey({ autoIncrement: true }),
 	profileId: integer("profile_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
-	movieId: integer("movie_id").references(() => movies.id),
-	episodeId: integer("episode_id").references(() => episodes.id),
+	movieId: integer("movie_id").references(() => movies.id, { onDelete: "cascade" }),
+	episodeId: integer("episode_id").references(() => episodes.id, { onDelete: "cascade" }),
 	currentTime: integer("current_time").notNull(),
 	duration: integer("duration"),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
@@ -6918,10 +6912,34 @@ const sessions$1 = sqliteTable("sessions", {
 	lastSeenAt: integer("last_seen_at").notNull(),
 	userAgent: text("user_agent")
 });
+const settings = sqliteTable("settings", {
+	key: text("key").primaryKey(),
+	value: text("value").notNull(),
+	updatedAt: integer("updated_at").notNull()
+});
+const scanJobs = sqliteTable("scan_jobs", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	startedAt: integer("started_at", { mode: "timestamp" }).notNull(),
+	endedAt: integer("ended_at", { mode: "timestamp" }),
+	status: text("status").notNull(),
+	added: integer("added").notNull().default(0),
+	updated: integer("updated").notNull().default(0),
+	total: integer("total").notNull().default(0),
+	errorMessage: text("error_message")
+});
+const subtitles = sqliteTable("subtitles", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	movieId: integer("movie_id").references(() => movies.id, { onDelete: "cascade" }),
+	episodeId: integer("episode_id").references(() => episodes.id, { onDelete: "cascade" }),
+	filePath: text("file_path").notNull(),
+	language: text("language").notNull(),
+	format: text("format").notNull()
+});
 //#endregion
 //#region src/database/index.ts
 ensureConfigDirectory();
 const sqlite = new Database(databasePath);
+sqlite.pragma("foreign_keys = ON");
 const db = drizzle(sqlite, { schema: schema_exports });
 const __dirname$2 = path.dirname(fileURLToPath(import.meta.url));
 migrate(db, { migrationsFolder: path.resolve(__dirname$2, "../../drizzle") });
@@ -7593,6 +7611,78 @@ episodeStreamRoutes.get("/:id", async (context) => {
 	} });
 });
 //#endregion
+//#region src/api/routes/filesystem.ts
+async function listWindowsDrives() {
+	const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+	const drives = [];
+	await Promise.all(letters.map(async (letter) => {
+		const drivePath = `${letter}:\\`;
+		try {
+			await access(drivePath, constants.R_OK);
+			drives.push({
+				name: `${letter}:`,
+				path: drivePath
+			});
+		} catch {}
+	}));
+	drives.sort((a, b) => a.name.localeCompare(b.name));
+	return drives;
+}
+function listPosixRoots() {
+	const entries = [{
+		name: "/",
+		path: "/"
+	}];
+	const home = homedir();
+	if (home && home !== "/") entries.push({
+		name: `Home (${home})`,
+		path: home
+	});
+	return entries;
+}
+async function listRoots() {
+	return {
+		entries: process.platform === "win32" ? await listWindowsDrives() : listPosixRoots(),
+		parent: null,
+		path: "",
+		separator: path.sep
+	};
+}
+function isAtFilesystemRoot(resolved) {
+	return path.dirname(resolved) === resolved;
+}
+async function listDirectory(inputPath) {
+	const resolved = path.resolve(inputPath);
+	return {
+		entries: (await readdir(resolved, { withFileTypes: true })).filter((dirent) => dirent.isDirectory() && !dirent.name.startsWith(".")).map((dirent) => ({
+			name: dirent.name,
+			path: path.join(resolved, dirent.name)
+		})).sort((a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" })),
+		parent: isAtFilesystemRoot(resolved) ? null : path.dirname(resolved),
+		path: resolved,
+		separator: path.sep
+	};
+}
+const filesystemRoutes = new Hono();
+filesystemRoutes.get("/browse", async (context) => {
+	const rawPath = context.req.query("path");
+	const trimmed = typeof rawPath === "string" ? rawPath.trim() : "";
+	if (trimmed.length === 0) {
+		const response = await listRoots();
+		return context.json(response);
+	}
+	try {
+		const response = await listDirectory(trimmed);
+		return context.json(response);
+	} catch (caught) {
+		const code = caught && typeof caught === "object" && "code" in caught ? String(caught.code) : "unknown";
+		if (code === "ENOENT") return context.json({ error: { message: `Folder doesn't exist: ${trimmed}. Check the path and try again.` } }, 404);
+		if (code === "EACCES" || code === "EPERM") return context.json({ error: { message: `Jukebox doesn't have permission to read ${trimmed}. Check the server's file permissions.` } }, 403);
+		if (code === "ENOTDIR") return context.json({ error: { message: `${trimmed} is a file, not a folder. Pick a folder instead.` } }, 400);
+		return context.json({ error: { message: `Couldn't list ${trimmed}: ${code}.` } }, 500);
+	}
+});
+//#endregion
 //#region src/api/routes/hello.ts
 const helloRoutes = new Hono();
 helloRoutes.get("/", (c) => c.json({
@@ -7605,6 +7695,309 @@ helloRoutes.put("/", (c) => c.json({
 }));
 helloRoutes.get("/:name", (c) => c.json({ message: `Hello, ${c.req.param("name")}!` }));
 //#endregion
+//#region src/services/filename-parser.ts
+const subtitleExtensions$1 = {
+	".ass": "ass",
+	".srt": "srt",
+	".vtt": "vtt"
+};
+const threeLetterToTwoLetter = {
+	ara: "ar",
+	ces: "cs",
+	cze: "cs",
+	dan: "da",
+	deu: "de",
+	dut: "nl",
+	ell: "el",
+	eng: "en",
+	fin: "fi",
+	fra: "fr",
+	fre: "fr",
+	ger: "de",
+	gre: "el",
+	heb: "he",
+	hin: "hi",
+	hun: "hu",
+	ind: "id",
+	ita: "it",
+	jpn: "ja",
+	kor: "ko",
+	nld: "nl",
+	nor: "no",
+	pol: "pl",
+	por: "pt",
+	ron: "ro",
+	rum: "ro",
+	rus: "ru",
+	spa: "es",
+	swe: "sv",
+	tha: "th",
+	tur: "tr",
+	ukr: "uk",
+	vie: "vi",
+	zho: "zh",
+	chi: "zh"
+};
+const fullNameToCode = {
+	arabic: "ar",
+	chinese: "zh",
+	czech: "cs",
+	danish: "da",
+	dutch: "nl",
+	english: "en",
+	finnish: "fi",
+	french: "fr",
+	german: "de",
+	greek: "el",
+	hebrew: "he",
+	hindi: "hi",
+	hungarian: "hu",
+	indonesian: "id",
+	italian: "it",
+	japanese: "ja",
+	korean: "ko",
+	norwegian: "no",
+	polish: "pl",
+	portuguese: "pt",
+	romanian: "ro",
+	russian: "ru",
+	spanish: "es",
+	swedish: "sv",
+	thai: "th",
+	turkish: "tr",
+	ukrainian: "uk",
+	vietnamese: "vi"
+};
+const subtitleModifiers = new Set([
+	"cc",
+	"forced",
+	"hoh",
+	"sdh"
+]);
+/**
+* Parse a movie filename to extract title and year.
+* The year marks the boundary between the title and technical info.
+*
+* Examples:
+* - Jurassic.Park.1993.720p.BrRip.264.YIFY.mp4 -> { title: "Jurassic Park", year: 1993 }
+* - The.Social.Network.(2010).1080p.BrRip.x264.mp4 -> { title: "The Social Network", year: 2010 }
+*/
+function parseFilename(fileName) {
+	const name = fileName.replace(/\.[^.]+$/, "");
+	const bracketYearMatch = name.match(/[([]((?:19|20)\d{2})[)\]]/);
+	if (bracketYearMatch?.[1]) {
+		const year = parseInt(bracketYearMatch[1], 10);
+		const yearIndex = bracketYearMatch.index ?? 0;
+		let title = name.substring(0, yearIndex);
+		title = title.replace(/[._]/g, " ").replace(/\s+/g, " ").trim();
+		title = title.replace(/[-–—]+$/, "").trim();
+		return {
+			title,
+			year
+		};
+	}
+	const yearPattern = /[.\s]((?:19|20)\d{2})[.\s]/g;
+	let match;
+	let bestMatch = null;
+	while ((match = yearPattern.exec(name)) !== null) {
+		const yearStr = match[1];
+		if (!yearStr) continue;
+		const year = parseInt(yearStr, 10);
+		const afterYear = name.substring(match.index + match[0].length);
+		const looksLikeTechInfo = /^(720p|1080p|2160p|4K|BluRay|BrRip|BDRip|WEB|HDTV|DVDRip|x264|x265|H\.?264)/i.test(afterYear);
+		if (looksLikeTechInfo || !bestMatch) {
+			bestMatch = {
+				year,
+				index: match.index
+			};
+			if (looksLikeTechInfo) break;
+		}
+	}
+	if (bestMatch) {
+		let title = name.substring(0, bestMatch.index);
+		title = title.replace(/[._]/g, " ").replace(/\s+/g, " ").trim();
+		title = title.replace(/[-–—]+$/, "").trim();
+		return {
+			title,
+			year: bestMatch.year
+		};
+	}
+	return {
+		title: name.replace(/[._]/g, " ").replace(/\s+/g, " ").trim(),
+		year: null
+	};
+}
+/**
+* Extract year from a filename if present
+*/
+function extractYear(fileName) {
+	return parseFilename(fileName).year;
+}
+/**
+* Clean a movie filename to extract a readable title
+*/
+function cleanTitle(fileName) {
+	return parseFilename(fileName).title;
+}
+function normalizeLanguageToken(rawToken) {
+	const token = rawToken.toLowerCase();
+	if (subtitleModifiers.has(token)) return null;
+	if (fullNameToCode[token]) return fullNameToCode[token];
+	if (threeLetterToTwoLetter[token]) return threeLetterToTwoLetter[token];
+	if (/^[a-z]{2}$/.test(token)) return token;
+	if (/^[a-z]{3}$/.test(token)) return token;
+	return null;
+}
+/**
+* Parse a sidecar subtitle filename. Returns the base name (the video filename
+* without the language suffix or extension), the detected language as a
+* lowercase code (ISO-639-1 when known, otherwise the raw token, or 'und' when
+* the filename has no language hint), and the subtitle format.
+*
+* Returns null when the file isn't a recognized subtitle format.
+*
+* Supported patterns:
+* - Movie.srt                      → language 'und'
+* - Movie.en.srt / Movie.eng.srt   → 'en'
+* - Movie.English.srt              → 'en'
+* - Movie.en.forced.srt            → 'en' (forced/sdh/cc/hoh modifiers ignored)
+* - Show.S01E02.en.srt             → baseName 'Show.S01E02', language 'en'
+*/
+function parseSubtitleFilename(fileName) {
+	const lastDot = fileName.lastIndexOf(".");
+	if (lastDot < 0) return null;
+	const format = subtitleExtensions$1[fileName.substring(lastDot).toLowerCase()];
+	if (!format) return null;
+	const tokens = fileName.substring(0, lastDot).split(".");
+	let language = "und";
+	let baseEndIndex = tokens.length;
+	for (let cursor = tokens.length - 1; cursor >= 1; cursor--) {
+		const token = tokens[cursor];
+		if (!token) continue;
+		const lowered = token.toLowerCase();
+		if (subtitleModifiers.has(lowered)) {
+			baseEndIndex = cursor;
+			continue;
+		}
+		const normalized = normalizeLanguageToken(token);
+		if (normalized) {
+			language = normalized;
+			baseEndIndex = cursor;
+		}
+		break;
+	}
+	return {
+		baseName: tokens.slice(0, baseEndIndex).join("."),
+		format,
+		language
+	};
+}
+//#endregion
+//#region src/services/media-extensions.ts
+const videoExtensions$1 = new Set([
+	".mp4",
+	".mkv",
+	".avi",
+	".mov",
+	".wmv",
+	".m4v",
+	".webm",
+	".flv",
+	".mpeg",
+	".mpg"
+]);
+const subtitleExtensions = new Set([
+	".ass",
+	".srt",
+	".vtt"
+]);
+//#endregion
+//#region src/services/subtitles.ts
+const languageNames = {
+	ar: "Arabic",
+	cs: "Czech",
+	da: "Danish",
+	de: "German",
+	el: "Greek",
+	en: "English",
+	es: "Spanish",
+	fi: "Finnish",
+	fr: "French",
+	he: "Hebrew",
+	hi: "Hindi",
+	hu: "Hungarian",
+	id: "Indonesian",
+	it: "Italian",
+	ja: "Japanese",
+	ko: "Korean",
+	nl: "Dutch",
+	no: "Norwegian",
+	pl: "Polish",
+	pt: "Portuguese",
+	ro: "Romanian",
+	ru: "Russian",
+	sv: "Swedish",
+	th: "Thai",
+	tr: "Turkish",
+	uk: "Ukrainian",
+	vi: "Vietnamese",
+	zh: "Chinese"
+};
+/**
+* Map a language code to a human-readable label. Returns "Unknown" for the
+* undetermined sentinel and the raw code for languages not in our table.
+*/
+function languageDisplayName(code) {
+	if (code === "und") return "Unknown";
+	return languageNames[code] ?? code;
+}
+function stripVideoExtension(fileName) {
+	const extension = extname(fileName);
+	if (!extension) return fileName;
+	return fileName.substring(0, fileName.length - extension.length);
+}
+/**
+* Match sidecar subtitles to a video file. Siblings must already be filtered
+* to subtitle entries (see `readSubtitleSiblings`). A subtitle matches when
+* its base name (after stripping language suffix and modifiers) equals the
+* video filename without extension.
+*
+* Results are returned in stable order (by file path) so callers can compare
+* against existing rows without spurious diffs.
+*/
+function discoverSubtitlesForVideo(videoFilePath, siblingSubtitleFiles) {
+	const directory = dirname(videoFilePath);
+	const videoStem = stripVideoExtension(basename(videoFilePath));
+	const matches = [];
+	for (const sibling of siblingSubtitleFiles) {
+		const parsed = parseSubtitleFilename(sibling);
+		if (!parsed) continue;
+		if (parsed.baseName !== videoStem) continue;
+		matches.push({
+			filePath: join(directory, sibling),
+			format: parsed.format,
+			language: parsed.language
+		});
+	}
+	matches.sort((a, b) => a.filePath.localeCompare(b.filePath));
+	return matches;
+}
+/**
+* Convert SubRip (.srt) text into WebVTT (.vtt) text. Browsers don't natively
+* support .srt, so the streaming endpoint converts on the fly.
+*
+* Handles UTF-8 BOM, CRLF line endings, and the comma-vs-period decimal in
+* timestamps. Cue identifiers are preserved (they're optional in WebVTT but
+* harmless when present).
+*/
+function convertSrtToVtt(srt) {
+	let body = srt;
+	if (body.charCodeAt(0) === 65279) body = body.substring(1);
+	body = body.replace(/\r\n?/g, "\n");
+	body = body.replace(/(\d{2}:\d{2}:\d{2}),(\d{3})\s+-->\s+(\d{2}:\d{2}:\d{2}),(\d{3})/g, "$1.$2 --> $3.$4");
+	return `WEBVTT\n\n${body.trimStart()}`;
+}
+//#endregion
 //#region src/api/routes/library.ts
 const libraryRoutes = new Hono();
 libraryRoutes.get("/movies", async (c) => {
@@ -7614,9 +8007,19 @@ libraryRoutes.get("/movies", async (c) => {
 libraryRoutes.get("/movies/:id", async (c) => {
 	const id = parseInt(c.req.param("id"), 10);
 	if (isNaN(id)) return c.json({ error: { message: "Invalid movie ID" } }, 400);
-	const movie = await db.select().from(movies).where(eq(movies.id, id)).limit(1);
-	if (movie.length === 0) return c.json({ error: { message: "Movie not found" } }, 404);
-	return c.json(movie[0]);
+	const [movie] = await db.select().from(movies).where(eq(movies.id, id)).limit(1);
+	if (!movie) return c.json({ error: { message: "Movie not found" } }, 404);
+	const subtitles$2 = (await db.select().from(subtitles).where(eq(subtitles.movieId, id))).map((row) => ({
+		id: row.id,
+		displayLanguage: languageDisplayName(row.language),
+		format: row.format,
+		isSupported: row.format !== "ass",
+		language: row.language
+	}));
+	return c.json({
+		...movie,
+		subtitles: subtitles$2
+	});
 });
 //#endregion
 //#region src/api/routes/progress.ts
@@ -7641,11 +8044,17 @@ progressRoutes.get("/continue-watching", async (context) => {
 		...result,
 		type: "movie"
 	}));
-	const episodes$2 = episodeResults.map((result) => ({
+	const episodesSorted = episodeResults.map((result) => ({
 		...result,
 		type: "episode"
-	}));
-	const combined = [...movies$2, ...episodes$2].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 20);
+	})).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+	const seenShowIds = /* @__PURE__ */ new Set();
+	const dedupedEpisodes = episodesSorted.filter((item) => {
+		if (seenShowIds.has(item.show.id)) return false;
+		seenShowIds.add(item.show.id);
+		return true;
+	});
+	const combined = [...movies$2, ...dedupedEpisodes].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 20);
 	return context.json(combined);
 });
 progressRoutes.get("/:movieId", async (c) => {
@@ -7816,245 +8225,654 @@ var streamSSE = (c, cb, onError) => {
 	return c.newResponse(stream.responseReadable);
 };
 //#endregion
-//#region src/services/tmdb.ts
-const tmdbBaseUrl = "https://api.themoviedb.org/3";
-function getApiKey() {
-	const apiKey = getConfig()?.tmdbApiKey ?? process.env.TMDB_API_KEY ?? null;
-	if (!apiKey) throw new Error("TMDB API key is not configured");
-	return apiKey;
-}
-async function searchMovie(title, year) {
-	const apiKey = getApiKey();
-	const params = new URLSearchParams({
-		api_key: apiKey,
-		query: title
+//#region node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
 	});
-	if (year) params.set("year", year.toString());
-	const response = await fetch(`${tmdbBaseUrl}/search/movie?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB search failed: ${response.statusText}`);
-	return (await response.json()).results;
-}
-async function getMovieDetails(tmdbId) {
-	const apiKey = getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/movie/${tmdbId}?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB movie details failed: ${response.statusText}`);
+	return styles$1;
+}
+const ansiStyles = assembleStyles();
+//#endregion
+//#region node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process$1;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (process$1.platform === "win32") {
+		const osRelease = os$1.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+const supportsColor = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+//#endregion
+//#region node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+//#region node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+const styles = Object.create(null);
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+//#region node_modules/tiny-typescript-logger/dist/index.js
+var logLevelToName = {
+	[10]: "trace",
+	[20]: "debug",
+	[30]: "info",
+	[40]: "warn",
+	[50]: "error",
+	[60]: "fatal"
+};
+var logLevelToColor = {
+	[10]: "#ECD5E3",
+	[20]: "#ABDEE6",
+	[30]: "#97C1A9",
+	[40]: "#FDFD96",
+	[50]: "#FFB6B6",
+	[60]: "#FF6961"
+};
+var Logger = class {
+	debug(...items) {
+		this.log(20, ...items);
+	}
+	error(...items) {
+		this.log(50, ...items);
+	}
+	fatal(...items) {
+		this.log(60, ...items);
+	}
+	info(...items) {
+		this.log(30, ...items);
+	}
+	log(level, ...items) {
+		if (items.length === 0) return;
+		const message = this.isString(items[0]) ? items.shift() : "";
+		const formattedMessage = this.formatMessage(level, message);
+		console.log(formattedMessage, ...items);
+	}
+	trace(...items) {
+		this.log(10, ...items);
+	}
+	warn(...items) {
+		this.log(40, ...items);
+	}
+	formatMessage(level, message) {
+		const date = (/* @__PURE__ */ new Date()).toISOString();
+		const formattedDate = chalk.dim(date);
+		const logLevelName = logLevelToName[level] ?? "unknown";
+		const logLevelColor = logLevelToColor[level] ?? "#f1f5f9";
+		return [
+			`[${chalk.hex(logLevelColor)(logLevelName.toUpperCase())}]`,
+			formattedDate,
+			message
+		].join(" ");
+	}
+	isString(value) {
+		return typeof value === "string";
+	}
+};
+var log = new Logger();
+//#endregion
+//#region src/services/metadata.ts
+const defaultApiBaseUrl = "https://movie-data-api.artgaard.workers.dev";
+function getApiBaseUrl() {
+	const fromEnv = process.env.JUKEBOX_METADATA_API_URL?.trim();
+	if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv.replace(/\/+$/, "");
+	return defaultApiBaseUrl;
+}
+async function apiGet(path) {
+	const response = await fetch(`${getApiBaseUrl()}${path}`);
+	if (response.status === 404) throw new NotFoundError(path);
+	if (!response.ok) throw new Error(`Metadata API request failed with status ${response.status} for ${path}`);
 	return await response.json();
 }
-async function getMovieVideos(tmdbId) {
-	const apiKey = getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/movie/${tmdbId}/videos?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB movie videos failed: ${response.statusText}`);
-	return (await response.json()).results;
-}
-function getTrailerUrl(videos) {
-	const youtubeVideos = videos.filter((v) => v.site === "YouTube");
-	for (const type of [
-		"Trailer",
-		"Teaser",
-		"Clip"
-	]) {
-		const video = youtubeVideos.find((v) => v.type === type);
-		if (video) return `https://www.youtube.com/watch?v=${video.key}`;
+var NotFoundError = class extends Error {
+	constructor(path) {
+		super(`Metadata API returned 404 for ${path}`);
+		this.name = "NotFoundError";
 	}
-	if (youtubeVideos.length > 0 && youtubeVideos[0]) return `https://www.youtube.com/watch?v=${youtubeVideos[0].key}`;
-	return null;
+};
+function mapMovie(apiMovie) {
+	return {
+		externalId: apiMovie.id,
+		title: apiMovie.title,
+		year: apiMovie.year,
+		overview: apiMovie.overview,
+		runtime: apiMovie.runtime,
+		genres: JSON.stringify(apiMovie.genres),
+		rating: apiMovie.rating,
+		posterUrl: apiMovie.posterUrl,
+		backdropUrl: apiMovie.backdropUrl,
+		trailerUrl: apiMovie.trailerUrl
+	};
+}
+function mapShow(apiShow) {
+	return {
+		externalId: apiShow.id,
+		title: apiShow.title,
+		year: apiShow.year,
+		overview: apiShow.overview,
+		genres: JSON.stringify(apiShow.genres),
+		rating: apiShow.rating,
+		posterUrl: apiShow.posterUrl,
+		backdropUrl: apiShow.backdropUrl,
+		numberOfSeasons: apiShow.numberOfSeasons
+	};
+}
+function mapSeason(apiSeason) {
+	return {
+		seasonNumber: apiSeason.seasonNumber,
+		name: apiSeason.name,
+		overview: apiSeason.overview,
+		posterUrl: apiSeason.posterUrl,
+		episodes: apiSeason.episodes.map((episode) => ({
+			episodeNumber: episode.episodeNumber,
+			title: episode.title,
+			overview: episode.overview,
+			runtime: episode.runtime,
+			stillUrl: episode.stillUrl
+		}))
+	};
 }
 async function fetchMovieMetadata(title, year) {
 	try {
-		getApiKey();
-	} catch {
+		const search = new URLSearchParams({ title });
+		if (year !== void 0) search.set("year", year.toString());
+		const { results } = await apiGet(`/movies/search?${search.toString()}`);
+		const bestMatch = results[0];
+		if (!bestMatch) return null;
+		return mapMovie(bestMatch);
+	} catch (caughtError) {
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for movie "${title}" (${year ?? "no year"}) failed — continuing without metadata: ${message}`);
 		return null;
 	}
-	const results = await searchMovie(title, year);
-	if (results.length === 0 || !results[0]) return null;
-	const bestMatch = results[0];
-	const [details, videos] = await Promise.all([getMovieDetails(bestMatch.id), getMovieVideos(bestMatch.id)]);
-	const releaseYear = details.release_date ? parseInt(details.release_date.split("-")[0] ?? "0", 10) || null : null;
-	return {
-		tmdbId: details.id,
-		title: details.title,
-		year: releaseYear,
-		overview: details.overview,
-		runtime: details.runtime,
-		genres: JSON.stringify(details.genres.map((g) => g.name)),
-		rating: details.vote_average,
-		posterPath: details.poster_path,
-		backdropPath: details.backdrop_path,
-		trailerUrl: getTrailerUrl(videos)
-	};
 }
-async function searchShow(title, year) {
-	const apiKey = getApiKey();
-	const params = new URLSearchParams({
-		api_key: apiKey,
-		query: title
-	});
-	if (year) params.set("first_air_date_year", year.toString());
-	const response = await fetch(`${tmdbBaseUrl}/search/tv?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB TV search failed: ${response.statusText}`);
-	return (await response.json()).results;
-}
-async function getShowDetails(tmdbId) {
-	const apiKey = getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/tv/${tmdbId}?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB show details failed: ${response.statusText}`);
-	return await response.json();
+async function fetchMovieByExternalId(externalId) {
+	try {
+		return mapMovie(await apiGet(`/movies/${encodeURIComponent(externalId)}`));
+	} catch (caughtError) {
+		if (caughtError instanceof NotFoundError) return null;
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for movie id=${externalId} failed — continuing without metadata: ${message}`);
+		return null;
+	}
 }
-async function getSeasonDetails(tmdbId, seasonNumber) {
-	const apiKey = getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/tv/${tmdbId}/season/${seasonNumber}?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB season details failed: ${response.statusText}`);
-	return await response.json();
+async function fetchShowByExternalId(externalId) {
+	try {
+		return mapShow(await apiGet(`/shows/${encodeURIComponent(externalId)}`));
+	} catch (caughtError) {
+		if (caughtError instanceof NotFoundError) return null;
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for show id=${externalId} failed — continuing without metadata: ${message}`);
+		return null;
+	}
 }
 async function fetchShowMetadata(title, year) {
 	try {
-		getApiKey();
-	} catch {
+		const search = new URLSearchParams({ title });
+		if (year !== void 0) search.set("year", year.toString());
+		const { results } = await apiGet(`/shows/search?${search.toString()}`);
+		const bestMatch = results[0];
+		if (!bestMatch) return null;
+		return mapShow(bestMatch);
+	} catch (caughtError) {
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for show "${title}" (${year ?? "no year"}) failed — continuing without metadata: ${message}`);
 		return null;
 	}
-	const results = await searchShow(title, year);
-	if (results.length === 0 || !results[0]) return null;
-	const bestMatch = results[0];
-	const details = await getShowDetails(bestMatch.id);
-	const firstAirYear = details.first_air_date ? parseInt(details.first_air_date.split("-")[0] ?? "0", 10) || null : null;
-	return {
-		tmdbId: details.id,
-		title: details.name,
-		year: firstAirYear,
-		overview: details.overview,
-		genres: JSON.stringify(details.genres.map((g) => g.name)),
-		rating: details.vote_average,
-		posterPath: details.poster_path,
-		backdropPath: details.backdrop_path,
-		numberOfSeasons: details.number_of_seasons
-	};
 }
-async function fetchSeasonMetadata(tmdbId, seasonNumber) {
+async function fetchSeasonMetadata(externalId, seasonNumber) {
 	try {
-		getApiKey();
-	} catch {
+		return mapSeason(await apiGet(`/shows/${encodeURIComponent(externalId)}/seasons/${seasonNumber}`));
+	} catch (caughtError) {
+		if (caughtError instanceof NotFoundError) return null;
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for show id=${externalId} season=${seasonNumber} failed — continuing without metadata: ${message}`);
 		return null;
 	}
-	const details = await getSeasonDetails(tmdbId, seasonNumber);
-	return {
-		seasonNumber: details.season_number,
-		name: details.name,
-		overview: details.overview,
-		posterPath: details.poster_path,
-		episodes: details.episodes.map((episode) => ({
-			episodeNumber: episode.episode_number,
-			title: episode.name,
-			overview: episode.overview,
-			runtime: episode.runtime,
-			stillPath: episode.still_path
-		}))
-	};
 }
 //#endregion
-//#region src/services/filename-parser.ts
+//#region src/services/subtitle-sync.ts
 /**
-* Parse a movie filename to extract title and year.
-* The year marks the boundary between the title and technical info.
-*
-* Examples:
-* - Jurassic.Park.1993.720p.BrRip.264.YIFY.mp4 -> { title: "Jurassic Park", year: 1993 }
-* - The.Social.Network.(2010).1080p.BrRip.x264.mp4 -> { title: "The Social Network", year: 2010 }
+* Replace the subtitle rows attached to a movie with the freshly discovered
+* sidecars. We delete-and-reinsert rather than diffing so a renamed or
+* removed sidecar disappears on the next scan without bookkeeping.
 */
-function parseFilename(fileName) {
-	const name = fileName.replace(/\.[^.]+$/, "");
-	const bracketYearMatch = name.match(/[([]((?:19|20)\d{2})[)\]]/);
-	if (bracketYearMatch?.[1]) {
-		const year = parseInt(bracketYearMatch[1], 10);
-		const yearIndex = bracketYearMatch.index ?? 0;
-		let title = name.substring(0, yearIndex);
-		title = title.replace(/[._]/g, " ").replace(/\s+/g, " ").trim();
-		title = title.replace(/[-–—]+$/, "").trim();
-		return {
-			title,
-			year
-		};
-	}
-	const yearPattern = /[.\s]((?:19|20)\d{2})[.\s]/g;
-	let match;
-	let bestMatch = null;
-	while ((match = yearPattern.exec(name)) !== null) {
-		const yearStr = match[1];
-		if (!yearStr) continue;
-		const year = parseInt(yearStr, 10);
-		const afterYear = name.substring(match.index + match[0].length);
-		const looksLikeTechInfo = /^(720p|1080p|2160p|4K|BluRay|BrRip|BDRip|WEB|HDTV|DVDRip|x264|x265|H\.?264)/i.test(afterYear);
-		if (looksLikeTechInfo || !bestMatch) {
-			bestMatch = {
-				year,
-				index: match.index
-			};
-			if (looksLikeTechInfo) break;
-		}
-	}
-	if (bestMatch) {
-		let title = name.substring(0, bestMatch.index);
-		title = title.replace(/[._]/g, " ").replace(/\s+/g, " ").trim();
-		title = title.replace(/[-–—]+$/, "").trim();
-		return {
-			title,
-			year: bestMatch.year
-		};
-	}
-	return {
-		title: name.replace(/[._]/g, " ").replace(/\s+/g, " ").trim(),
-		year: null
-	};
-}
-/**
-* Extract year from a filename if present
-*/
-function extractYear(fileName) {
-	return parseFilename(fileName).year;
+async function syncSubtitlesForMovie(movieId, discovered) {
+	await db.delete(subtitles).where(eq(subtitles.movieId, movieId));
+	if (discovered.length === 0) return;
+	const rows = discovered.map((subtitle) => ({
+		movieId,
+		episodeId: null,
+		filePath: subtitle.filePath,
+		format: subtitle.format,
+		language: subtitle.language
+	}));
+	await db.insert(subtitles).values(rows);
 }
 /**
-* Clean a movie filename to extract a readable title
+* Same as syncSubtitlesForMovie but for episodes. See note above.
 */
-function cleanTitle(fileName) {
-	return parseFilename(fileName).title;
+async function syncSubtitlesForEpisode(episodeId, discovered) {
+	await db.delete(subtitles).where(eq(subtitles.episodeId, episodeId));
+	if (discovered.length === 0) return;
+	const rows = discovered.map((subtitle) => ({
+		movieId: null,
+		episodeId,
+		filePath: subtitle.filePath,
+		format: subtitle.format,
+		language: subtitle.language
+	}));
+	await db.insert(subtitles).values(rows);
 }
 //#endregion
 //#region src/services/scanner.ts
-const VIDEO_EXTENSIONS = new Set([
-	".mp4",
-	".mkv",
-	".avi",
-	".mov",
-	".wmv",
-	".m4v",
-	".webm",
-	".flv",
-	".mpeg",
-	".mpg"
-]);
 /**
-* Recursively scan a directory for video files
+* Recursively scan a directory for video files. Each yielded entry includes
+* the subtitle siblings sitting in the same folder so subtitle discovery
+* piggybacks on the directory read instead of re-globbing per file.
 */
 async function* scanDirectory(dir) {
 	const entries = await readdir(dir, { withFileTypes: true });
+	const videoFiles = [];
+	const subtitleSiblings = [];
+	const subdirectories = [];
 	for (const entry of entries) {
-		const fullPath = join(dir, entry.name);
-		if (entry.isDirectory()) yield* scanDirectory(fullPath);
-		else if (entry.isFile()) {
-			const ext = extname(entry.name).toLowerCase();
-			if (VIDEO_EXTENSIONS.has(ext)) yield fullPath;
+		if (entry.isDirectory()) {
+			subdirectories.push(entry.name);
+			continue;
 		}
-	}
+		if (!entry.isFile()) continue;
+		const extension = extname(entry.name).toLowerCase();
+		if (videoExtensions$1.has(extension)) videoFiles.push(entry.name);
+		else if (subtitleExtensions.has(extension)) subtitleSiblings.push(entry.name);
+	}
+	for (const videoFile of videoFiles) yield {
+		filePath: join(dir, videoFile),
+		subtitleSiblings
+	};
+	for (const subdirectory of subdirectories) yield* scanDirectory(join(dir, subdirectory));
 }
 async function scanLibrary(libraryPath, onProgress) {
 	let added = 0;
 	let updated = 0;
 	let total = 0;
 	console.log(`Scanning: ${libraryPath}`);
-	for await (const filePath of scanDirectory(libraryPath)) {
+	for await (const { filePath, subtitleSiblings } of scanDirectory(libraryPath)) {
 		total++;
 		const fileName = basename(filePath);
 		const ext = extname(fileName).toLowerCase();
@@ -8065,38 +8883,48 @@ async function scanLibrary(libraryPath, onProgress) {
 			fileSize = (await stat(filePath)).size;
 		} catch {}
 		const now = /* @__PURE__ */ new Date();
+		const discoveredSubtitles = discoverSubtitlesForVideo(filePath, subtitleSiblings);
 		const existing = await db.select().from(movies).where(eq(movies.filePath, filePath)).limit(1);
+		let movieId;
 		if (existing.length > 0 && existing[0]) {
 			const movie = existing[0];
-			let tmdbData = {};
-			if (!movie.tmdbId) {
-				console.log(`  Fetching TMDB metadata for: ${title}`);
+			movieId = movie.id;
+			let metadataUpdate = {};
+			if (!movie.externalId) {
+				console.log(`  Fetching metadata for: ${title}`);
 				const metadata = await fetchMovieMetadata(title, year ?? void 0);
-				if (metadata) tmdbData = {
-					tmdbId: metadata.tmdbId,
+				if (metadata) metadataUpdate = {
+					externalId: metadata.externalId,
 					year: metadata.year,
 					overview: metadata.overview,
 					runtime: metadata.runtime,
 					genres: metadata.genres,
 					rating: metadata.rating,
-					posterPath: metadata.posterPath,
-					backdropPath: metadata.backdropPath,
+					posterUrl: metadata.posterUrl,
+					backdropUrl: metadata.backdropUrl,
 					trailerUrl: metadata.trailerUrl
 				};
-			} else if (!movie.trailerUrl && movie.tmdbId) {
-				console.log(`  Fetching trailer for: ${movie.title}`);
-				try {
-					const trailerUrl = getTrailerUrl(await getMovieVideos(movie.tmdbId));
-					if (trailerUrl) tmdbData = { trailerUrl };
-				} catch {}
+			} else if (!movie.posterUrl || !movie.backdropUrl || !movie.trailerUrl) {
+				console.log(`  Refreshing metadata for: ${movie.title}`);
+				const refreshed = await fetchMovieByExternalId(movie.externalId);
+				if (refreshed) metadataUpdate = {
+					year: movie.year ?? refreshed.year,
+					overview: movie.overview ?? refreshed.overview,
+					runtime: movie.runtime ?? refreshed.runtime,
+					genres: movie.genres ?? refreshed.genres,
+					rating: movie.rating ?? refreshed.rating,
+					posterUrl: movie.posterUrl ?? refreshed.posterUrl,
+					backdropUrl: movie.backdropUrl ?? refreshed.backdropUrl,
+					trailerUrl: movie.trailerUrl ?? refreshed.trailerUrl
+				};
 			}
 			await db.update(movies).set({
-				title: movie.tmdbId ? movie.title : title,
+				title: movie.externalId ? movie.title : title,
 				fileName,
 				fileSize,
 				extension: ext,
 				updatedAt: now,
-				...tmdbData
+				...metadataUpdate
 			}).where(eq(movies.filePath, filePath));
 			updated++;
 			await onProgress?.({
@@ -8105,7 +8933,7 @@ async function scanLibrary(libraryPath, onProgress) {
 				updated
 			});
 		} else {
-			console.log(`  Fetching TMDB metadata for: ${title}`);
+			console.log(`  Fetching metadata for: ${title}`);
 			const metadata = await fetchMovieMetadata(title, year ?? void 0);
 			const newMovie = {
 				title: metadata?.title ?? title,
@@ -8115,17 +8943,17 @@ async function scanLibrary(libraryPath, onProgress) {
 				extension: ext,
 				createdAt: now,
 				updatedAt: now,
-				tmdbId: metadata?.tmdbId ?? null,
+				externalId: metadata?.externalId ?? null,
 				year: metadata?.year ?? year,
 				overview: metadata?.overview ?? null,
 				runtime: metadata?.runtime ?? null,
 				genres: metadata?.genres ?? null,
 				rating: metadata?.rating ?? null,
-				posterPath: metadata?.posterPath ?? null,
-				backdropPath: metadata?.backdropPath ?? null,
+				posterUrl: metadata?.posterUrl ?? null,
+				backdropUrl: metadata?.backdropUrl ?? null,
 				trailerUrl: metadata?.trailerUrl ?? null
 			};
-			await db.insert(movies).values(newMovie);
+			movieId = (await db.insert(movies).values(newMovie).returning({ id: movies.id }))[0]?.id ?? null;
 			added++;
 			await onProgress?.({
 				added,
@@ -8133,6 +8961,7 @@ async function scanLibrary(libraryPath, onProgress) {
 				updated
 			});
 		}
+		if (movieId !== null) await syncSubtitlesForMovie(movieId, discoveredSubtitles);
 		console.log(`  Found: ${title}`);
 	}
 	return {
@@ -8143,7 +8972,7 @@ async function scanLibrary(libraryPath, onProgress) {
 }
 //#endregion
 //#region src/services/episode-parser.ts
-const videoExtensions$1 = new Set([
+const videoExtensions = new Set([
 	".mp4",
 	".mkv",
 	".avi",
@@ -8159,7 +8988,7 @@ const episodePattern = /S(\d+)[Ee](\d+)/;
 const technicalPatterns = /\b(720p|1080p|2160p|4K|BluRay|BrRip|BDRip|WEB|WEB-DL|HDTV|DVDRip|x264|x265|H\.?264|HEVC|AAC|AC3|DD5|10bit)\b/i;
 function parseEpisodeFilename(fileName) {
 	const ext = extname(fileName).toLowerCase();
-	if (!videoExtensions$1.has(ext)) return null;
+	if (!videoExtensions.has(ext)) return null;
 	const name = fileName.replace(/\.[^.]+$/, "");
 	const match = name.match(episodePattern);
 	if (!match?.[1] || !match[2]) return null;
@@ -8253,18 +9082,6 @@ function parseSeasonFolder(folderName) {
 }
 //#endregion
 //#region src/services/show-scanner.ts
-const videoExtensions = new Set([
-	".mp4",
-	".mkv",
-	".avi",
-	".mov",
-	".wmv",
-	".m4v",
-	".webm",
-	".flv",
-	".mpeg",
-	".mpg"
-]);
 async function scanEpisodesInDirectory(directory) {
 	let entries;
 	try {
@@ -8272,10 +9089,16 @@ async function scanEpisodesInDirectory(directory) {
 	} catch {
 		return [];
 	}
-	const episodes = [];
+	const subtitleSiblings = [];
+	const videoEntries = [];
 	for (const entry of entries) {
 		const extension = extname(entry).toLowerCase();
-		if (!videoExtensions.has(extension)) continue;
+		if (videoExtensions$1.has(extension)) videoEntries.push(entry);
+		else if (subtitleExtensions.has(extension)) subtitleSiblings.push(entry);
+	}
+	const episodes = [];
+	for (const entry of videoEntries) {
+		const extension = extname(entry).toLowerCase();
 		const parsed = parseEpisodeFilename(entry);
 		if (!parsed) continue;
 		const filePath = join(directory, entry);
@@ -8290,7 +9113,8 @@ async function scanEpisodesInDirectory(directory) {
 			extension,
 			seasonNumber: parsed.seasonNumber,
 			episodeNumber: parsed.episodeNumber,
-			title: parsed.title
+			title: parsed.title,
+			subtitleSiblings
 		});
 	}
 	return episodes;
@@ -8390,29 +9214,43 @@ async function scanShowLibrary(libraryPath, onProgress) {
 		const folderPath = discoveredShow.folders[0] ?? "";
 		const existingShows = await db.select().from(shows).where(eq(shows.folderPath, folderPath)).limit(1);
 		let showId;
-		let tmdbId;
+		let externalId;
 		if (existingShows.length > 0 && existingShows[0]) {
-			showId = existingShows[0].id;
-			tmdbId = existingShows[0].tmdbId ?? null;
+			const existingShow = existingShows[0];
+			showId = existingShow.id;
+			externalId = existingShow.externalId ?? null;
+			if (externalId !== null && (!existingShow.posterUrl || !existingShow.backdropUrl || !existingShow.overview)) {
+				console.log(`  Refreshing metadata for show: ${existingShow.title}`);
+				const refreshed = await fetchShowByExternalId(externalId);
+				if (refreshed) await db.update(shows).set({
+					year: existingShow.year ?? refreshed.year,
+					overview: existingShow.overview ?? refreshed.overview,
+					genres: existingShow.genres ?? refreshed.genres,
+					rating: existingShow.rating ?? refreshed.rating,
+					posterUrl: existingShow.posterUrl ?? refreshed.posterUrl,
+					backdropUrl: existingShow.backdropUrl ?? refreshed.backdropUrl,
+					updatedAt: /* @__PURE__ */ new Date()
+				}).where(eq(shows.id, showId));
+			}
 		} else {
-			console.log(`  Fetching TMDB metadata for show: ${name}`);
+			console.log(`  Fetching metadata for show: ${name}`);
 			const metadata = await fetchShowMetadata(name, year ?? void 0);
 			const now = /* @__PURE__ */ new Date();
 			const newShow = {
 				title: metadata?.title ?? name,
 				folderPath,
-				tmdbId: metadata?.tmdbId ?? null,
+				externalId: metadata?.externalId ?? null,
 				year: metadata?.year ?? year ?? null,
 				overview: metadata?.overview ?? null,
 				genres: metadata?.genres ?? null,
 				rating: metadata?.rating ?? null,
-				posterPath: metadata?.posterPath ?? null,
-				backdropPath: metadata?.backdropPath ?? null,
+				posterUrl: metadata?.posterUrl ?? null,
+				backdropUrl: metadata?.backdropUrl ?? null,
 				createdAt: now,
 				updatedAt: now
 			};
 			showId = (await db.insert(shows).values(newShow).returning({ id: shows.id }))[0]?.id ?? 0;
-			tmdbId = metadata?.tmdbId ?? null;
+			externalId = metadata?.externalId ?? null;
 		}
 		const seasonMap = /* @__PURE__ */ new Map();
 		for (const episode of episodes$1) {
@@ -8421,36 +9259,38 @@ async function scanShowLibrary(libraryPath, onProgress) {
 			seasonMap.set(episode.seasonNumber, seasonEpisodes);
 		}
 		for (const [seasonNumber, seasonEpisodes] of seasonMap) {
-			let tmdbEpisodes = [];
+			let metadataEpisodes = [];
 			const existingSeasons = await db.select().from(seasons).where(and(eq(seasons.showId, showId), eq(seasons.seasonNumber, seasonNumber))).limit(1);
 			let seasonId;
 			if (existingSeasons.length > 0 && existingSeasons[0]) {
 				seasonId = existingSeasons[0].id;
-				if (tmdbId !== null) tmdbEpisodes = (await fetchSeasonMetadata(tmdbId, seasonNumber))?.episodes ?? [];
+				if (externalId !== null) metadataEpisodes = (await fetchSeasonMetadata(externalId, seasonNumber))?.episodes ?? [];
 			} else {
 				let seasonMetadata = null;
-				if (tmdbId !== null) {
-					console.log(`  Fetching TMDB metadata for season ${seasonNumber} of: ${name}`);
-					seasonMetadata = await fetchSeasonMetadata(tmdbId, seasonNumber);
-					tmdbEpisodes = seasonMetadata?.episodes ?? [];
+				if (externalId !== null) {
+					console.log(`  Fetching metadata for season ${seasonNumber} of: ${name}`);
+					seasonMetadata = await fetchSeasonMetadata(externalId, seasonNumber);
+					metadataEpisodes = seasonMetadata?.episodes ?? [];
 				}
 				const newSeason = {
 					showId,
 					seasonNumber,
 					name: seasonMetadata?.name ?? null,
 					overview: seasonMetadata?.overview ?? null,
-					posterPath: seasonMetadata?.posterPath ?? null,
+					posterUrl: seasonMetadata?.posterUrl ?? null,
 					episodeCount: seasonEpisodes.length
 				};
 				seasonId = (await db.insert(seasons).values(newSeason).returning({ id: seasons.id }))[0]?.id ?? 0;
 			}
 			for (const scannedEpisode of seasonEpisodes) {
 				total++;
-				const tmdbEpisode = tmdbEpisodes.find((e) => e.episodeNumber === scannedEpisode.episodeNumber);
-				const episodeTitle = tmdbEpisode?.title ?? scannedEpisode.title ?? `Episode ${scannedEpisode.episodeNumber}`;
+				const metadataEpisode = metadataEpisodes.find((e) => e.episodeNumber === scannedEpisode.episodeNumber);
+				const episodeTitle = metadataEpisode?.title ?? scannedEpisode.title ?? `Episode ${scannedEpisode.episodeNumber}`;
 				const existingEpisodes = await db.select().from(episodes).where(eq(episodes.filePath, scannedEpisode.filePath)).limit(1);
 				const now = /* @__PURE__ */ new Date();
-				if (existingEpisodes.length > 0) {
+				let episodeId;
+				if (existingEpisodes.length > 0 && existingEpisodes[0]) {
+					episodeId = existingEpisodes[0].id;
 					await db.update(episodes).set({
 						title: episodeTitle,
 						fileName: scannedEpisode.fileName,
@@ -8475,14 +9315,14 @@ async function scanShowLibrary(libraryPath, onProgress) {
 						fileName: scannedEpisode.fileName,
 						fileSize: scannedEpisode.fileSize,
 						extension: scannedEpisode.extension,
-						tmdbId: tmdbEpisode ? null : null,
-						overview: tmdbEpisode?.overview ?? null,
-						runtime: tmdbEpisode?.runtime ?? null,
-						stillPath: tmdbEpisode?.stillPath ?? null,
+						externalId: null,
+						overview: metadataEpisode?.overview ?? null,
+						runtime: metadataEpisode?.runtime ?? null,
+						stillUrl: metadataEpisode?.stillUrl ?? null,
 						createdAt: now,
 						updatedAt: now
 					};
-					await db.insert(episodes).values(newEpisode);
+					episodeId = (await db.insert(episodes).values(newEpisode).returning({ id: episodes.id }))[0]?.id ?? null;
 					added++;
 					await onProgress?.({
 						added,
@@ -8490,6 +9330,10 @@ async function scanShowLibrary(libraryPath, onProgress) {
 						updated
 					});
 				}
+				if (episodeId !== null) {
+					const discoveredSubtitles = discoverSubtitlesForVideo(scannedEpisode.filePath, scannedEpisode.subtitleSiblings);
+					await syncSubtitlesForEpisode(episodeId, discoveredSubtitles);
+				}
 			}
 		}
 		console.log(`  Found show: ${name} (${episodes$1.length} episodes)`);
@@ -8501,6 +9345,178 @@ async function scanShowLibrary(libraryPath, onProgress) {
 	};
 }
 //#endregion
+//#region src/services/scan-manager.ts
+const interruptedMessage = "Server restarted mid-scan. Run a manual scan to resume.";
+function createScanManager(dependencies = {}) {
+	const database = dependencies.database ?? db;
+	const scanLibrary$1 = dependencies.scanLibrary ?? scanLibrary;
+	const scanShowLibrary$1 = dependencies.scanShowLibrary ?? scanShowLibrary;
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(0);
+	let currentJob = null;
+	async function getStatus() {
+		if (currentJob) {
+			const [latest] = await database.select().from(scanJobs).where(eq(scanJobs.id, currentJob.id)).limit(1);
+			return {
+				currentJob: latest ?? currentJob,
+				isRunning: true,
+				lastJob: latest ?? currentJob
+			};
+		}
+		const [last] = await database.select().from(scanJobs).orderBy(desc(scanJobs.startedAt)).limit(1);
+		return {
+			currentJob: null,
+			isRunning: false,
+			lastJob: last ?? null
+		};
+	}
+	function isRunning() {
+		return currentJob !== null;
+	}
+	async function recoverInterruptedJobs() {
+		const now = /* @__PURE__ */ new Date();
+		const running = await database.select().from(scanJobs).where(eq(scanJobs.status, "running"));
+		if (running.length === 0) return;
+		for (const job of running) await database.update(scanJobs).set({
+			endedAt: now,
+			errorMessage: interruptedMessage,
+			status: "error"
+		}).where(eq(scanJobs.id, job.id));
+		log.info(`Marked ${running.length} interrupted scan job(s) as failed after a restart.`);
+	}
+	async function start() {
+		if (currentJob) return { status: "already-running" };
+		const libraries$4 = await database.select().from(libraries);
+		if (libraries$4.length === 0) return {
+			status: "no-libraries",
+			message: "No libraries configured. Add a library in Settings before scanning."
+		};
+		const startedAt = /* @__PURE__ */ new Date();
+		const [inserted] = await database.insert(scanJobs).values({
+			startedAt,
+			status: "running",
+			added: 0,
+			updated: 0,
+			total: 0
+		}).returning();
+		invariant(inserted, "Failed to create scan_jobs row.");
+		currentJob = inserted;
+		emitter.emit("job-started", {
+			jobId: inserted.id,
+			startedAt: inserted.startedAt
+		});
+		let totalAdded = 0;
+		let totalUpdated = 0;
+		let totalFound = 0;
+		const libraryErrors = [];
+		try {
+			for (let index = 0; index < libraries$4.length; index++) {
+				const library = libraries$4[index];
+				if (!library) continue;
+				const libraryType = library.type === "shows" ? "shows" : "movies";
+				emitter.emit("library-start", {
+					index,
+					libraryId: library.id,
+					name: library.name,
+					type: libraryType
+				});
+				const onProgress = async (progress) => {
+					const aggregate = {
+						added: totalAdded + progress.added,
+						total: totalFound + progress.total,
+						updated: totalUpdated + progress.updated
+					};
+					await database.update(scanJobs).set(aggregate).where(eq(scanJobs.id, inserted.id));
+					emitter.emit("file-scanned", {
+						...progress,
+						index,
+						libraryId: library.id
+					});
+				};
+				try {
+					const result = libraryType === "shows" ? await scanShowLibrary$1(library.path, onProgress) : await scanLibrary$1(library.path, onProgress);
+					totalAdded += result.added;
+					totalUpdated += result.updated;
+					totalFound += result.total;
+					emitter.emit("library-complete", {
+						...result,
+						index,
+						libraryId: library.id
+					});
+				} catch (caughtError) {
+					const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+					libraryErrors.push(`${library.name} — ${message}`);
+					emitter.emit("library-error", {
+						error: message,
+						index,
+						libraryId: library.id
+					});
+				}
+			}
+			const endedAt = /* @__PURE__ */ new Date();
+			const status = libraryErrors.length > 0 ? "error" : "done";
+			const errorMessage = libraryErrors.length > 0 ? libraryErrors.join("; ") : null;
+			await database.update(scanJobs).set({
+				added: totalAdded,
+				endedAt,
+				errorMessage,
+				status,
+				total: totalFound,
+				updated: totalUpdated
+			}).where(eq(scanJobs.id, inserted.id));
+			const payload = {
+				added: totalAdded,
+				errorMessage,
+				jobId: inserted.id,
+				status,
+				total: totalFound,
+				updated: totalUpdated
+			};
+			emitter.emit("job-completed", payload);
+			return {
+				added: totalAdded,
+				errorMessage: errorMessage ?? void 0,
+				status,
+				total: totalFound,
+				updated: totalUpdated
+			};
+		} catch (caughtError) {
+			const endedAt = /* @__PURE__ */ new Date();
+			const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+			await database.update(scanJobs).set({
+				added: totalAdded,
+				endedAt,
+				errorMessage: message,
+				status: "error",
+				total: totalFound,
+				updated: totalUpdated
+			}).where(eq(scanJobs.id, inserted.id));
+			emitter.emit("job-failed", {
+				error: message,
+				jobId: inserted.id
+			});
+			return {
+				added: totalAdded,
+				errorMessage: message,
+				status: "error",
+				total: totalFound,
+				updated: totalUpdated
+			};
+		} finally {
+			currentJob = null;
+		}
+	}
+	return {
+		getStatus,
+		isRunning,
+		off: (event, listener) => emitter.off(event, listener),
+		on: (event, listener) => emitter.on(event, listener),
+		recoverInterruptedJobs,
+		start
+	};
+}
+const scanManager = createScanManager();
+//#endregion
 //#region src/api/routes/scan.ts
 const scanRoutes = new Hono();
 scanRoutes.get("/libraries", async (context) => {
@@ -8512,74 +9528,571 @@ scanRoutes.get("/libraries", async (context) => {
 		type: library.type
 	})));
 });
-scanRoutes.get("/stream", async (context) => {
-	const libraries$2 = await db.select().from(libraries);
-	if (libraries$2.length === 0) return context.json({ error: { message: "No libraries configured" } }, 400);
+scanRoutes.get("/status", async (context) => {
+	const status = await scanManager.getStatus();
+	return context.json({
+		currentJob: status.currentJob ? {
+			added: status.currentJob.added,
+			endedAt: status.currentJob.endedAt?.toISOString() ?? null,
+			errorMessage: status.currentJob.errorMessage,
+			id: status.currentJob.id,
+			startedAt: status.currentJob.startedAt.toISOString(),
+			status: status.currentJob.status,
+			total: status.currentJob.total,
+			updated: status.currentJob.updated
+		} : null,
+		isRunning: status.isRunning,
+		lastJob: status.lastJob ? {
+			added: status.lastJob.added,
+			endedAt: status.lastJob.endedAt?.toISOString() ?? null,
+			errorMessage: status.lastJob.errorMessage,
+			id: status.lastJob.id,
+			startedAt: status.lastJob.startedAt.toISOString(),
+			status: status.lastJob.status,
+			total: status.lastJob.total,
+			updated: status.lastJob.updated
+		} : null
+	});
+});
+scanRoutes.post("/start", async (context) => {
+	if ((await db.select().from(libraries)).length === 0) return context.json({ error: { message: "No libraries configured. Add a library in Settings before scanning." } }, 400);
+	if (scanManager.isRunning()) return context.json({ status: "already-running" });
+	scanManager.start().catch((caughtError) => {
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		console.error(`Manual scan failed: ${message}`);
+	});
+	return context.json({ status: "started" });
+});
+scanRoutes.get("/stream", (context) => {
 	return streamSSE(context, async (stream) => {
-		let totalAdded = 0;
-		let totalUpdated = 0;
-		let totalFound = 0;
-		for (let i = 0; i < libraries$2.length; i++) {
-			const library = libraries$2[i];
-			if (!library) continue;
-			await stream.writeSSE({
+		const onLibraryStart = (event) => {
+			stream.writeSSE({
 				event: "library-start",
-				data: JSON.stringify({ index: i })
+				data: JSON.stringify(event)
 			});
-			try {
-				const onProgress = async (progress) => {
-					await stream.writeSSE({
-						event: "file-scanned",
-						data: JSON.stringify({
-							index: i,
-							...progress
-						})
-					});
-				};
-				let result;
-				if (library.type === "movies") result = await scanLibrary(library.path, onProgress);
-				else result = await scanShowLibrary(library.path, onProgress);
-				totalAdded += result.added;
-				totalUpdated += result.updated;
-				totalFound += result.total;
-				await stream.writeSSE({
-					event: "library-complete",
-					data: JSON.stringify({
-						added: result.added,
-						index: i,
-						total: result.total,
-						updated: result.updated
-					})
-				});
-			} catch (error) {
+		};
+		const onFileScanned = (event) => {
+			stream.writeSSE({
+				event: "file-scanned",
+				data: JSON.stringify(event)
+			});
+		};
+		const onLibraryComplete = (event) => {
+			stream.writeSSE({
+				event: "library-complete",
+				data: JSON.stringify(event)
+			});
+		};
+		const onLibraryError = (event) => {
+			stream.writeSSE({
+				event: "library-error",
+				data: JSON.stringify(event)
+			});
+		};
+		const onScanComplete = (event) => {
+			stream.writeSSE({
+				event: "scan-complete",
+				data: JSON.stringify({
+					added: event.added,
+					errorMessage: event.errorMessage,
+					found: event.total,
+					status: event.status,
+					updated: event.updated
+				})
+			});
+		};
+		scanManager.on("library-start", onLibraryStart);
+		scanManager.on("file-scanned", onFileScanned);
+		scanManager.on("library-complete", onLibraryComplete);
+		scanManager.on("library-error", onLibraryError);
+		scanManager.on("job-completed", onScanComplete);
+		await stream.writeSSE({
+			event: "ready",
+			data: JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString() })
+		});
+		stream.onAbort(() => {
+			scanManager.off("library-start", onLibraryStart);
+			scanManager.off("file-scanned", onFileScanned);
+			scanManager.off("library-complete", onLibraryComplete);
+			scanManager.off("library-error", onLibraryError);
+			scanManager.off("job-completed", onScanComplete);
+		});
+		const keepAliveMs = 15e3;
+		try {
+			while (!stream.aborted && !stream.closed) {
+				await stream.sleep(keepAliveMs);
+				if (stream.aborted || stream.closed) break;
 				await stream.writeSSE({
-					event: "library-error",
-					data: JSON.stringify({
-						error: error instanceof Error ? error.message : "Unknown error",
-						index: i
-					})
+					event: "ping",
+					data: "{}"
 				});
 			}
+		} catch {}
+	});
+});
+//#endregion
+//#region src/services/fts-query-parser.ts
+/**
+* Convert raw user input into a safe SQLite FTS5 MATCH expression.
+*
+* FTS5 has a query syntax with operators (AND, OR, NEAR, NOT), prefix
+* wildcards (*), column filters (title:foo), and quoted phrases. We don't
+* want users to accidentally trigger any of that — and we don't want
+* adversarial input to crash the parser. So we:
+*
+*   1. Split the input on whitespace.
+*   2. Strip every character except letters, digits, and the underscore
+*      from each token. This drops quotes, asterisks, parens, colons,
+*      and operator-like punctuation.
+*   3. Wrap each surviving token in double quotes (so reserved words like
+*      `OR` or `NEAR` are treated as literal terms) and append `*` for
+*      prefix matching.
+*   4. Join the tokens with spaces. FTS5 implicitly ANDs them.
+*
+* Returns null when there is nothing searchable (empty input, only
+* whitespace, or only stripped characters).
+*/
+function buildFtsMatchQuery(rawInput) {
+	const tokens = rawInput.split(/\s+/).map((token) => sanitizeToken(token)).filter((token) => token.length > 0);
+	if (tokens.length === 0) return null;
+	return tokens.map((token) => `"${token}"*`).join(" ");
+}
+function sanitizeToken(token) {
+	return token.replace(/[^\p{L}\p{N}_]+/gu, "");
+}
+//#endregion
+//#region src/api/routes/search.ts
+const defaultLimit = 20;
+const maxLimit = 50;
+const maxQueryLength = 256;
+const searchRoutes = new Hono();
+searchRoutes.get("/", (context) => {
+	const queryParameter = context.req.query("q");
+	if (queryParameter === void 0) return context.json({ error: { message: "Add a `q` query parameter to search. Example: /api/search?q=dune" } }, 400);
+	if (queryParameter.length > maxQueryLength) return context.json({ error: { message: "Search query is too long. Shorten it to under 256 characters." } }, 400);
+	const limit = parseLimit(context.req.query("limit"));
+	if (limit === null) return context.json({ error: { message: "`limit` must be a positive integer between 1 and 50." } }, 400);
+	const matchExpression = buildFtsMatchQuery(queryParameter);
+	if (matchExpression === null) return context.json({
+		episodes: [],
+		indexEmpty: false,
+		movies: [],
+		shows: []
+	});
+	try {
+		const movies = searchMovies(matchExpression, limit);
+		const shows = searchShows(matchExpression, limit);
+		const episodes = searchEpisodes(matchExpression, limit);
+		const response = {
+			episodes,
+			indexEmpty: movies.length === 0 && shows.length === 0 && episodes.length === 0 && isLibraryEmpty(),
+			movies,
+			shows
+		};
+		return context.json(response);
+	} catch (error) {
+		log.error("Search query failed.", error);
+		return context.json({ error: { message: "Your search couldn't be parsed. Try simpler terms or fewer special characters." } }, 400);
+	}
+});
+function isLibraryEmpty() {
+	const [movieCountRow] = db.all(sql`
+    SELECT COUNT(*) AS count FROM movies
+  `);
+	const [showCountRow] = db.all(sql`
+    SELECT COUNT(*) AS count FROM shows
+  `);
+	const [episodeCountRow] = db.all(sql`
+    SELECT COUNT(*) AS count FROM episodes
+  `);
+	return (movieCountRow?.count ?? 0) + (showCountRow?.count ?? 0) + (episodeCountRow?.count ?? 0) === 0;
+}
+function parseLimit(raw) {
+	if (raw === void 0 || raw.trim() === "") return defaultLimit;
+	const parsed = Number(raw);
+	if (!Number.isInteger(parsed) || parsed < 1) return null;
+	return Math.min(parsed, maxLimit);
+}
+function searchMovies(matchExpression, limit) {
+	return db.all(sql`
+    SELECT
+      movies.id AS id,
+      movies.title AS title,
+      movies.year AS year,
+      movies.overview AS overview,
+      movies.poster_url AS poster_url,
+      movies.backdrop_url AS backdrop_url
+    FROM movies_fts
+    JOIN movies ON movies.rowid = movies_fts.rowid
+    WHERE movies_fts MATCH ${matchExpression}
+    ORDER BY bm25(movies_fts) ASC
+    LIMIT ${limit}
+  `).map((row) => ({
+		backdropUrl: row.backdrop_url,
+		id: row.id,
+		overview: row.overview,
+		posterUrl: row.poster_url,
+		title: row.title,
+		year: row.year
+	}));
+}
+function searchShows(matchExpression, limit) {
+	return db.all(sql`
+    SELECT
+      shows.id AS id,
+      shows.title AS title,
+      shows.year AS year,
+      shows.overview AS overview,
+      shows.poster_url AS poster_url,
+      shows.backdrop_url AS backdrop_url
+    FROM shows_fts
+    JOIN shows ON shows.rowid = shows_fts.rowid
+    WHERE shows_fts MATCH ${matchExpression}
+    ORDER BY bm25(shows_fts) ASC
+    LIMIT ${limit}
+  `).map((row) => ({
+		backdropUrl: row.backdrop_url,
+		id: row.id,
+		overview: row.overview,
+		posterUrl: row.poster_url,
+		title: row.title,
+		year: row.year
+	}));
+}
+function searchEpisodes(matchExpression, limit) {
+	return db.all(sql`
+    SELECT
+      episodes.id AS id,
+      episodes.show_id AS show_id,
+      episodes.season_number AS season_number,
+      episodes.episode_number AS episode_number,
+      episodes.title AS title,
+      episodes.overview AS overview,
+      episodes.still_url AS still_url,
+      shows.title AS show_title
+    FROM episodes_fts
+    JOIN episodes ON episodes.rowid = episodes_fts.rowid
+    LEFT JOIN shows ON shows.id = episodes.show_id
+    WHERE episodes_fts MATCH ${matchExpression}
+    ORDER BY bm25(episodes_fts) ASC
+    LIMIT ${limit}
+  `).map((row) => ({
+		episodeNumber: row.episode_number,
+		id: row.id,
+		overview: row.overview,
+		seasonNumber: row.season_number,
+		showId: row.show_id,
+		showTitle: row.show_title ?? "",
+		stillUrl: row.still_url,
+		title: row.title
+	}));
+}
+//#endregion
+//#region src/services/settings.ts
+const scanScheduleSettingKey = "scanSchedule";
+const scanScheduleValues = [
+	"off",
+	"6h",
+	"12h",
+	"24h"
+];
+function isScanScheduleValue(value) {
+	return scanScheduleValues.includes(value);
+}
+/**
+* Read a setting value from the DB. Returns null when the key is not set.
+*
+* Accepts an optional database instance so tests and scripts can pass an
+* in-memory SQLite instance instead of the singleton.
+*/
+async function getSetting(key, database = db) {
+	const [row] = await database.select().from(settings).where(eq(settings.key, key)).limit(1);
+	return row?.value ?? null;
+}
+/**
+* Upsert a setting value.
+*
+* Uses a single INSERT ... ON CONFLICT so two concurrent callers don't both
+* read null, both INSERT, and fail with a UNIQUE constraint on the second.
+*/
+async function setSetting(key, value, database = db) {
+	const now = Date.now();
+	await database.insert(settings).values({
+		key,
+		value,
+		updatedAt: now
+	}).onConflictDoUpdate({
+		target: settings.key,
+		set: {
+			value,
+			updatedAt: now
 		}
-		await stream.writeSSE({
-			event: "scan-complete",
-			data: JSON.stringify({
-				added: totalAdded,
-				found: totalFound,
-				updated: totalUpdated
-			})
-		});
 	});
+}
+//#endregion
+//#region src/services/scheduler.ts
+const millisecondsPerHour = 3600 * 1e3;
+function scheduleIntervalMilliseconds(value) {
+	switch (value) {
+		case "off": return null;
+		case "6h": return 6 * millisecondsPerHour;
+		case "12h": return 12 * millisecondsPerHour;
+		case "24h": return 24 * millisecondsPerHour;
+	}
+}
+async function defaultGetSchedule() {
+	const stored = await getSetting(scanScheduleSettingKey);
+	if (stored === null) return "off";
+	if (isScanScheduleValue(stored)) return stored;
+	log.warn(`Unknown scanSchedule value "${stored}" in settings. Falling back to "off".`);
+	return "off";
+}
+function createScheduler(dependencies = {}) {
+	const getSchedule = dependencies.getSchedule ?? defaultGetSchedule;
+	const scanManager$1 = dependencies.scanManager ?? {
+		isRunning: () => scanManager.isRunning(),
+		start: () => scanManager.start()
+	};
+	let currentSchedule = "off";
+	let nextRunAt = null;
+	let timer = null;
+	function clearTimer() {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+	}
+	function scheduleNext(intervalMs) {
+		clearTimer();
+		nextRunAt = new Date(Date.now() + intervalMs);
+		timer = setTimeout(() => {
+			tick();
+		}, intervalMs);
+	}
+	async function tick() {
+		if (scanManager$1.isRunning()) log.debug("Scheduler tick skipped — a scan is already running.");
+		else try {
+			const result = await scanManager$1.start();
+			if (result.status === "error") {
+				const message = "errorMessage" in result && result.errorMessage ? `: ${result.errorMessage}` : ".";
+				log.warn(`Scheduled scan finished with errors${message}`);
+			} else if (result.status === "no-libraries") log.debug("Scheduled scan skipped — no libraries configured.");
+		} catch (caughtError) {
+			const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+			log.warn(`Scheduled scan failed to start: ${message}. Check the scan page.`);
+		}
+		const activeInterval = scheduleIntervalMilliseconds(currentSchedule);
+		if (activeInterval === null) {
+			nextRunAt = null;
+			return;
+		}
+		scheduleNext(activeInterval);
+	}
+	function applySchedule(value) {
+		currentSchedule = value;
+		const intervalMs = scheduleIntervalMilliseconds(value);
+		if (intervalMs === null) {
+			clearTimer();
+			nextRunAt = null;
+			log.info("Scan scheduler is off.");
+			return;
+		}
+		scheduleNext(intervalMs);
+		log.info(`Next scheduled scan at ${nextRunAt?.toISOString() ?? "unknown"} (${value}).`);
+	}
+	return {
+		getInfo: () => ({
+			nextRunAt,
+			schedule: currentSchedule
+		}),
+		start: async () => {
+			applySchedule(await getSchedule());
+		},
+		stop: () => {
+			clearTimer();
+			currentSchedule = "off";
+			nextRunAt = null;
+		},
+		updateSchedule: (value) => {
+			applySchedule(value);
+		}
+	};
+}
+const scheduler = createScheduler();
+//#endregion
+//#region src/api/routes/settings.ts
+const reservedKeys = new Set([scanScheduleSettingKey]);
+const reservedKeyRoute = { [scanScheduleSettingKey]: "/api/settings/scan-schedule" };
+async function pathIsReadable(path) {
+	try {
+		await access(path, constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function validateLibraryInput(input) {
+	if (typeof input !== "object" || input === null) return "Library entry must be an object.";
+	const record = input;
+	const name = typeof record.name === "string" ? record.name.trim() : "";
+	const libraryPath = typeof record.path === "string" ? record.path.trim() : "";
+	const type = record.type;
+	if (libraryPath.length === 0) return "Library path is required.";
+	if (type !== "movies" && type !== "shows") return "Library type must be \"movies\" or \"shows\".";
+	return {
+		name,
+		path: libraryPath,
+		type
+	};
+}
+/**
+* Build the LIKE pattern that matches any file path under the given library
+* root. Escapes SQL LIKE wildcards so a path containing `%` or `_` doesn't
+* accidentally match siblings.
+*/
+function libraryPathPrefixPattern(libraryPath) {
+	const resolved = path.resolve(libraryPath);
+	return `${(resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_")}%`;
+}
+const settingsRoutes = new Hono();
+settingsRoutes.get("/libraries", async (context) => {
+	const libraries$2 = await db.select().from(libraries);
+	return context.json(libraries$2.map((library) => ({
+		id: library.id,
+		name: library.name,
+		path: library.path,
+		type: library.type
+	})));
+});
+settingsRoutes.post("/libraries", async (context) => {
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		return context.json({ error: { message: "Invalid request body." } }, 400);
+	}
+	const parsed = validateLibraryInput(body);
+	if (typeof parsed === "string") return context.json({ error: { message: parsed } }, 400);
+	if (!await pathIsReadable(parsed.path)) return context.json({ error: { message: `Library path doesn't exist or isn't readable: ${parsed.path}. Check the path and Jukebox's file permissions.` } }, 400);
+	const [existing] = await db.select().from(libraries).where(eq(libraries.path, parsed.path)).limit(1);
+	if (existing) return context.json({ error: { message: `A library at ${parsed.path} already exists.` } }, 400);
+	const resolvedName = parsed.name.length > 0 ? parsed.name : parsed.path.split(/[\\/]/).filter(Boolean).pop() ?? parsed.type;
+	const [created] = await db.insert(libraries).values({
+		name: resolvedName,
+		path: parsed.path,
+		type: parsed.type,
+		createdAt: /* @__PURE__ */ new Date()
+	}).returning();
+	if (!created) return context.json({ error: { message: "Failed to create library." } }, 500);
+	return context.json({
+		id: created.id,
+		name: created.name,
+		path: created.path,
+		type: created.type
+	}, 201);
+});
+settingsRoutes.delete("/libraries/:id", async (context) => {
+	const id = Number.parseInt(context.req.param("id"), 10);
+	if (!Number.isFinite(id)) return context.json({ error: { message: "Invalid library id." } }, 400);
+	const [existing] = await db.select().from(libraries).where(eq(libraries.id, id)).limit(1);
+	if (!existing) return context.json({ error: { message: "Library not found." } }, 404);
+	const force = new URL(context.req.url).searchParams.get("force") === "true";
+	const pattern = libraryPathPrefixPattern(existing.path);
+	if (!force) {
+		const referenceCount = countLibraryReferences(existing, pattern);
+		if (referenceCount > 0) {
+			const noun = existing.type === "movies" ? referenceCount === 1 ? "movie" : "movies" : referenceCount === 1 ? "show" : "shows";
+			return context.json({ error: {
+				message: `Couldn't remove library — ${referenceCount} ${noun} reference it. Remove them first or use 'Force remove'.`,
+				referenceCount
+			} }, 409);
+		}
+		db.delete(libraries).where(eq(libraries.id, id)).run();
+		return context.json({ success: true });
+	}
+	db.transaction((tx) => {
+		if (existing.type === "movies") {
+			const movieIds = tx.select({ id: movies.id }).from(movies).where(sql`${movies.filePath} LIKE ${pattern} ESCAPE '\\'`).all().map((row) => row.id);
+			if (movieIds.length > 0) {
+				tx.delete(watchProgress).where(inArray(watchProgress.movieId, movieIds)).run();
+				tx.delete(movies).where(inArray(movies.id, movieIds)).run();
+			}
+		} else {
+			const showIds = tx.select({ id: shows.id }).from(shows).where(sql`${shows.folderPath} LIKE ${pattern} ESCAPE '\\'`).all().map((row) => row.id);
+			if (showIds.length > 0) {
+				const episodeIds = tx.select({ id: episodes.id }).from(episodes).where(inArray(episodes.showId, showIds)).all().map((row) => row.id);
+				if (episodeIds.length > 0) {
+					tx.delete(watchProgress).where(inArray(watchProgress.episodeId, episodeIds)).run();
+					tx.delete(episodes).where(inArray(episodes.id, episodeIds)).run();
+				}
+				tx.delete(seasons).where(inArray(seasons.showId, showIds)).run();
+				tx.delete(shows).where(inArray(shows.id, showIds)).run();
+			}
+		}
+		tx.delete(libraries).where(eq(libraries.id, id)).run();
+	});
+	return context.json({ success: true });
+});
+function countLibraryReferences(library, pattern) {
+	if (library.type === "movies") {
+		const [row] = db.select({ count: sql`count(*)` }).from(movies).where(sql`${movies.filePath} LIKE ${pattern} ESCAPE '\\'`).all();
+		return row?.count ?? 0;
+	}
+	const [row] = db.select({ count: sql`count(*)` }).from(shows).where(sql`${shows.folderPath} LIKE ${pattern} ESCAPE '\\'`).all();
+	return row?.count ?? 0;
+}
+settingsRoutes.get("/scan-schedule", async (context) => {
+	const stored = await getSetting(scanScheduleSettingKey);
+	const value = stored !== null && isScanScheduleValue(stored) ? stored : "off";
+	const info = scheduler.getInfo();
+	return context.json({
+		nextRunAt: info.nextRunAt?.toISOString() ?? null,
+		schedule: value
+	});
+});
+settingsRoutes.put("/scan-schedule", async (context) => {
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		return context.json({ error: { message: "Invalid request body." } }, 400);
+	}
+	const schedule = typeof body.schedule === "string" ? body.schedule.trim() : "";
+	if (!isScanScheduleValue(schedule)) return context.json({ error: { message: "Scan schedule must be one of: off, 6h, 12h, 24h." } }, 400);
+	await setSetting(scanScheduleSettingKey, schedule);
+	scheduler.updateSchedule(schedule);
+	const info = scheduler.getInfo();
+	return context.json({
+		nextRunAt: info.nextRunAt?.toISOString() ?? null,
+		schedule
+	});
+});
+settingsRoutes.get("/:key", async (context) => {
+	const key = context.req.param("key");
+	if (reservedKeys.has(key)) return context.json({ error: { message: `Use GET ${reservedKeyRoute[key]} for this key.` } }, 400);
+	const value = await getSetting(key);
+	if (value === null) return context.json({ value: null });
+	return context.json({ value });
+});
+settingsRoutes.put("/:key", async (context) => {
+	const key = context.req.param("key");
+	if (reservedKeys.has(key)) return context.json({ error: { message: `Use PUT ${reservedKeyRoute[key]} for this key.` } }, 400);
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		return context.json({ error: { message: "Invalid request body." } }, 400);
+	}
+	if (typeof body.value !== "string") return context.json({ error: { message: "Setting value must be a string." } }, 400);
+	await setSetting(key, body.value);
+	return context.json({ value: body.value });
 });
 //#endregion
 //#region src/api/routes/setup.ts
 const setupRoutes = new Hono();
 setupRoutes.get("/", async (context) => {
-	const config = getConfig();
 	const libraries$1 = await db.select().from(libraries);
 	return context.json({
-		config: config ? { tmdbApiKey: config.tmdbApiKey } : null,
-		hasApiKey: config?.tmdbApiKey !== void 0 && config.tmdbApiKey !== "",
 		libraries: libraries$1.map((library) => ({
 			id: library.id,
 			name: library.name,
@@ -8592,9 +10105,7 @@ setupRoutes.get("/", async (context) => {
 });
 setupRoutes.post("/complete", async (context) => {
 	const body = await context.req.json();
-	if (!body.tmdbApiKey) return context.json({ error: { message: "TMDB API key is required" } }, 400);
 	if (!body.libraries || body.libraries.length === 0) return context.json({ error: { message: "At least one library is required" } }, 400);
-	await saveConfig({ tmdbApiKey: body.tmdbApiKey });
 	await db.delete(libraries);
 	const now = /* @__PURE__ */ new Date();
 	for (const library of body.libraries) await db.insert(libraries).values({
@@ -8746,17 +10257,6 @@ favoriteRoutes.delete("/", async (context) => {
 	return context.json({ error: { message: "movieId or showId required" } }, 400);
 });
 //#endregion
-//#region src/lib/watched.ts
-/**
-* Shared "watched" threshold used across the server and client.
-*
-* An episode (or movie) is considered complete once the profile has
-* progressed at least this fraction of the total duration. Kept in a single
-* module so server endpoints ("Up Next", next-episode) and client overlays
-* ("Up Next" countdown) can't drift.
-*/
-const watchedThreshold = .9;
-//#endregion
 //#region src/api/routes/shows.ts
 const showRoutes = new Hono();
 showRoutes.get("/", async (context) => {
@@ -8778,38 +10278,31 @@ showRoutes.get("/episodes/:id", async (context) => {
 	const [episode] = await db.select().from(episodes).where(eq(episodes.id, id)).limit(1);
 	if (!episode) return context.json({ error: { message: "Episode not found" } }, 404);
 	const [show] = await db.select().from(shows).where(eq(shows.id, episode.showId)).limit(1);
+	const subtitles$1 = (await db.select().from(subtitles).where(eq(subtitles.episodeId, id))).map((row) => ({
+		id: row.id,
+		displayLanguage: languageDisplayName(row.language),
+		format: row.format,
+		isSupported: row.format !== "ass",
+		language: row.language
+	}));
 	return context.json({
 		episode,
-		show
+		show,
+		subtitles: subtitles$1
 	});
 });
 showRoutes.get("/:showId/next-episode", async (context) => {
-	const profileId = context.get("profileId");
 	const showId = parseInt(context.req.param("showId"), 10);
 	const afterEpisodeIdParam = context.req.query("afterEpisodeId");
 	const afterEpisodeId = afterEpisodeIdParam ? parseInt(afterEpisodeIdParam, 10) : NaN;
 	if (isNaN(showId) || isNaN(afterEpisodeId)) return context.json({ error: { message: "Provide a numeric showId and a numeric afterEpisodeId query parameter." } }, 400);
 	const [currentEpisode] = await db.select().from(episodes).where(and(eq(episodes.id, afterEpisodeId), eq(episodes.showId, showId))).limit(1);
 	if (!currentEpisode) return context.json({ error: { message: "That episode does not belong to this show. Double-check the showId and afterEpisodeId." } }, 404);
-	const laterEpisodes = (await db.select().from(episodes).where(eq(episodes.showId, showId)).orderBy(episodes.seasonNumber, episodes.episodeNumber)).filter((candidate) => {
+	const nextEpisode = (await db.select().from(episodes).where(eq(episodes.showId, showId)).orderBy(episodes.seasonNumber, episodes.episodeNumber)).find((candidate) => {
 		if (candidate.seasonNumber > currentEpisode.seasonNumber) return true;
 		if (candidate.seasonNumber < currentEpisode.seasonNumber) return false;
 		return candidate.episodeNumber > currentEpisode.episodeNumber;
 	});
-	if (laterEpisodes.length === 0) return context.json({ error: { message: "No more episodes after this one." } }, 404);
-	const laterIds = laterEpisodes.map((candidate) => candidate.id);
-	const progressRows = await db.select().from(watchProgress).where(eq(watchProgress.profileId, profileId));
-	const progressByEpisodeId = /* @__PURE__ */ new Map();
-	for (const row of progressRows) if (row.episodeId !== null && laterIds.includes(row.episodeId)) progressByEpisodeId.set(row.episodeId, {
-		currentTime: row.currentTime,
-		duration: row.duration
-	});
-	const nextEpisode = laterEpisodes.find((candidate) => {
-		const progress = progressByEpisodeId.get(candidate.id);
-		if (!progress) return true;
-		if (!progress.duration || progress.duration <= 0) return true;
-		return progress.currentTime / progress.duration < watchedThreshold;
-	});
 	if (!nextEpisode) return context.json({ error: { message: "No more episodes after this one." } }, 404);
 	const [show] = await db.select().from(shows).where(eq(shows.id, showId)).limit(1);
 	return context.json({
@@ -8893,6 +10386,60 @@ streamRoutes.get("/:id", async (context) => {
 	} });
 });
 //#endregion
+//#region src/api/routes/subtitles.ts
+const subtitleRoutes = new Hono();
+const conversionFailedMessage = "Couldn't convert subtitle file. Check it's a valid SRT.";
+const outsideLibraryMessage = "Subtitle is outside the configured library paths. Rescan your libraries.";
+function subtitleIsInsideALibrary(subtitleFilePath, libraryPaths) {
+	const resolvedSubtitle = path.resolve(subtitleFilePath);
+	for (const libraryPath of libraryPaths) {
+		const resolvedLibrary = path.resolve(libraryPath);
+		const libraryWithSeparator = resolvedLibrary.endsWith(path.sep) ? resolvedLibrary : `${resolvedLibrary}${path.sep}`;
+		if (resolvedSubtitle.startsWith(libraryWithSeparator)) return true;
+	}
+	return false;
+}
+subtitleRoutes.get("/:id", async (context) => {
+	const id = parseInt(context.req.param("id"), 10);
+	if (isNaN(id)) return context.json({ error: { message: "Invalid subtitle ID" } }, 400);
+	const [subtitle] = await db.select().from(subtitles).where(eq(subtitles.id, id)).limit(1);
+	if (!subtitle) return context.json({ error: { message: "Subtitle not found" } }, 404);
+	const libraryPaths = (await db.select({ path: libraries.path }).from(libraries)).map((library) => library.path);
+	if (!subtitleIsInsideALibrary(subtitle.filePath, libraryPaths)) {
+		log.warn(`Refusing to serve subtitle ${subtitle.id} — ${subtitle.filePath} is not inside any configured library. Rescan the library to clean up stale rows.`);
+		return context.json({ error: { message: outsideLibraryMessage } }, 404);
+	}
+	if (subtitle.format === "ass") return context.text("ASS subtitles aren't supported by the web player. Convert the file to .srt or .vtt and rescan.", 415);
+	let raw;
+	try {
+		raw = await readFile(subtitle.filePath, "utf-8");
+	} catch (error) {
+		log.warn(`Couldn't read subtitle file ${subtitle.filePath} - ${error instanceof Error ? error.message : String(error)}. Make sure the file still exists at that path and rescan the library.`);
+		return context.text(conversionFailedMessage, 500);
+	}
+	if (subtitle.format === "vtt") return new Response(raw, {
+		status: 200,
+		headers: {
+			"Cache-Control": "public, max-age=3600",
+			"Content-Type": "text/vtt; charset=utf-8"
+		}
+	});
+	let converted;
+	try {
+		converted = convertSrtToVtt(raw);
+	} catch (error) {
+		log.warn(`Couldn't convert subtitle file ${subtitle.filePath} to WebVTT - ${error instanceof Error ? error.message : String(error)}. Convert the file to UTF-8 .vtt and rescan.`);
+		return context.text(conversionFailedMessage, 500);
+	}
+	return new Response(converted, {
+		status: 200,
+		headers: {
+			"Cache-Control": "public, max-age=3600",
+			"Content-Type": "text/vtt; charset=utf-8"
+		}
+	});
+});
+//#endregion
 //#region src/api/routes/transcode.ts
 const logger = {
 	error: (...args) => console.error("[transcode]", ...args),
@@ -9089,6 +10636,17 @@ try {
 	logger.warn("Failed to clear transcode root on boot:", error);
 }
 //#endregion
+//#region src/lib/watched.ts
+/**
+* Shared "watched" threshold used across the server and client.
+*
+* An episode (or movie) is considered complete once the profile has
+* progressed at least this fraction of the total duration. Kept in a single
+* module so server endpoints ("Up Next", next-episode) and client overlays
+* ("Up Next" countdown) can't drift.
+*/
+const watchedThreshold = .9;
+//#endregion
 //#region src/api/routes/up-next.ts
 const upNextRoutes = new Hono();
 upNextRoutes.get("/", async (context) => {
@@ -9154,11 +10712,15 @@ app.route("/api/library", libraryRoutes);
 app.route("/api/progress/episode", episodeProgressRoutes);
 app.route("/api/progress", progressRoutes);
 app.route("/api/scan", scanRoutes);
+app.route("/api/search", searchRoutes);
 app.route("/api/profiles", profileRoutes);
 app.route("/api/favorites", favoriteRoutes);
+app.route("/api/filesystem", filesystemRoutes);
+app.route("/api/settings", settingsRoutes);
 app.route("/api/setup", setupRoutes);
 app.route("/api/stream/episode", episodeStreamRoutes);
 app.route("/api/stream", streamRoutes);
+app.route("/api/subtitles", subtitleRoutes);
 app.route("/api/transcode", transcodeRoutes);
 app.get("/api", (c) => c.json({ message: "Jukebox API" }));
 const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
@@ -9237,6 +10799,8 @@ if (isDevelopment) {
 	await viteServer.listen();
 	setupViteProxy(vitePort);
 } else setupStaticServing();
+await scanManager.recoverInterruptedJobs();
+await scheduler.start();
 const server = serve({
 	fetch: app.fetch,
 	port
@@ -9262,6 +10826,7 @@ function printWelcome(boundPort) {
 function shutdown(signal) {
 	console.log(`\nReceived ${signal}, shutting down...`);
 	setTimeout(() => process.exit(1), 2e3).unref();
+	scheduler.stop();
 	server.close(() => {
 		if (viteServer) viteServer.close().finally(() => process.exit(0));
 		else process.exit(0);