jukebox-media-server 0.1.1 → 0.3.0

package/dist/server/index.js

@@ -1,19 +1,30 @@
-import { createReadStream, existsSync, mkdirSync, readFileSync, 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 from "crypto";
-import { createServer as createServer$1 } from "vite";
+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 { homedir } from "os";
+import { access, readFile, readdir, stat, writeFile } from "fs/promises";
+import os, { homedir } from "os";
+import { promisify } from "util";
+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;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -23,6 +34,20 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 //#endregion
 //#region node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
@@ -320,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;
 	}
@@ -2497,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 = (fn = console.log) => {
+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
@@ -3719,6 +3744,109 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
 	return result;
 }
 //#endregion
+//#region node_modules/hono/dist/helper/factory/index.js
+var createMiddleware = (middleware) => middleware;
+//#endregion
+//#region node_modules/hono/dist/utils/cookie.js
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+var parse = (cookie, name) => {
+	if (name && cookie.indexOf(name) === -1) return {};
+	const pairs = cookie.trim().split(";");
+	const parsedCookie = {};
+	for (let pairStr of pairs) {
+		pairStr = pairStr.trim();
+		const valueStartPos = pairStr.indexOf("=");
+		if (valueStartPos === -1) continue;
+		const cookieName = pairStr.substring(0, valueStartPos).trim();
+		if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) continue;
+		let cookieValue = pairStr.substring(valueStartPos + 1).trim();
+		if (cookieValue.startsWith("\"") && cookieValue.endsWith("\"")) cookieValue = cookieValue.slice(1, -1);
+		if (validCookieValueRegEx.test(cookieValue)) {
+			parsedCookie[cookieName] = cookieValue.indexOf("%") !== -1 ? tryDecode(cookieValue, decodeURIComponent_) : cookieValue;
+			if (name) break;
+		}
+	}
+	return parsedCookie;
+};
+var _serialize = (name, value, opt = {}) => {
+	let cookie = `${name}=${value}`;
+	if (name.startsWith("__Secure-") && !opt.secure) throw new Error("__Secure- Cookie must have Secure attributes");
+	if (name.startsWith("__Host-")) {
+		if (!opt.secure) throw new Error("__Host- Cookie must have Secure attributes");
+		if (opt.path !== "/") throw new Error("__Host- Cookie must have Path attributes with \"/\"");
+		if (opt.domain) throw new Error("__Host- Cookie must not have Domain attributes");
+	}
+	if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+		if (opt.maxAge > 3456e4) throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+		cookie += `; Max-Age=${opt.maxAge | 0}`;
+	}
+	if (opt.domain && opt.prefix !== "host") cookie += `; Domain=${opt.domain}`;
+	if (opt.path) cookie += `; Path=${opt.path}`;
+	if (opt.expires) {
+		if (opt.expires.getTime() - Date.now() > 3456e7) throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+		cookie += `; Expires=${opt.expires.toUTCString()}`;
+	}
+	if (opt.httpOnly) cookie += "; HttpOnly";
+	if (opt.secure) cookie += "; Secure";
+	if (opt.sameSite) cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+	if (opt.priority) cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;
+	if (opt.partitioned) {
+		if (!opt.secure) throw new Error("Partitioned Cookie must have Secure attributes");
+		cookie += "; Partitioned";
+	}
+	return cookie;
+};
+var serialize = (name, value, opt) => {
+	value = encodeURIComponent(value);
+	return _serialize(name, value, opt);
+};
+//#endregion
+//#region node_modules/hono/dist/helper/cookie/index.js
+var getCookie = (c, key, prefix) => {
+	const cookie = c.req.raw.headers.get("Cookie");
+	if (typeof key === "string") {
+		if (!cookie) return;
+		let finalKey = key;
+		if (prefix === "secure") finalKey = "__Secure-" + key;
+		else if (prefix === "host") finalKey = "__Host-" + key;
+		return parse(cookie, finalKey)[finalKey];
+	}
+	if (!cookie) return {};
+	return parse(cookie);
+};
+var generateCookie = (name, value, opt) => {
+	let cookie;
+	if (opt?.prefix === "secure") cookie = serialize("__Secure-" + name, value, {
+		path: "/",
+		...opt,
+		secure: true
+	});
+	else if (opt?.prefix === "host") cookie = serialize("__Host-" + name, value, {
+		...opt,
+		path: "/",
+		secure: true,
+		domain: void 0
+	});
+	else cookie = serialize(name, value, {
+		path: "/",
+		...opt
+	});
+	return cookie;
+};
+var setCookie = (c, name, value, opt) => {
+	const cookie = generateCookie(name, value, opt);
+	c.header("Set-Cookie", cookie, { append: true });
+};
+var deleteCookie = (c, name, opt) => {
+	const deletedCookie = getCookie(c, name, opt?.prefix);
+	setCookie(c, name, "", {
+		...opt,
+		maxAge: 0
+	});
+	return deletedCookie;
+};
+//#endregion
 //#region node_modules/drizzle-orm/selection-proxy.js
 var SelectionProxyHandler = class SelectionProxyHandler {
 	static [entityKind] = "SelectionProxyHandler";
@@ -4269,6 +4397,55 @@ const sqliteTable = (name, columns, extraConfig) => {
 	return sqliteTableBase(name, columns, extraConfig);
 };
 //#endregion
+//#region node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+	constructor(name, unique) {
+		this.name = name;
+		this.unique = unique;
+	}
+	static [entityKind] = "SQLiteIndexBuilderOn";
+	on(...columns) {
+		return new IndexBuilder(this.name, columns, this.unique);
+	}
+};
+var IndexBuilder = class {
+	static [entityKind] = "SQLiteIndexBuilder";
+	/** @internal */
+	config;
+	constructor(name, columns, unique) {
+		this.config = {
+			name,
+			columns,
+			unique,
+			where: void 0
+		};
+	}
+	/**
+	* Condition for partial index.
+	*/
+	where(condition) {
+		this.config.where = condition;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new Index(this.config, table);
+	}
+};
+var Index = class {
+	static [entityKind] = "SQLiteIndex";
+	config;
+	constructor(config, table) {
+		this.config = {
+			...config,
+			table
+		};
+	}
+};
+function uniqueIndex(name) {
+	return new IndexBuilderOn(name, true);
+}
+//#endregion
 //#region node_modules/drizzle-orm/sqlite-core/utils.js
 function extractUsedTable(table) {
 	if (is(table, SQLiteTable)) return [`${table[Table.Symbol.BaseName]}`];
@@ -6633,13 +6810,26 @@ async function saveConfig(config) {
 //#endregion
 //#region src/database/schema.ts
 var schema_exports = /* @__PURE__ */ __exportAll({
+	authConfig: () => authConfig,
 	episodes: () => episodes,
+	favorites: () => favorites,
 	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", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	name: text("name").notNull().unique(),
+	emoji: text("emoji").notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+});
 const libraries = sqliteTable("libraries", {
 	id: integer("id").primaryKey({ autoIncrement: true }),
 	name: text("name").notNull(),
@@ -6709,23 +6899,624 @@ const episodes = sqliteTable("episodes", {
 });
 const watchProgress = sqliteTable("watch_progress", {
 	id: integer("id").primaryKey({ autoIncrement: true }),
-	movieId: integer("movie_id").references(() => movies.id),
-	episodeId: integer("episode_id").references(() => episodes.id),
+	profileId: integer("profile_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+	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()
+}, (table) => [uniqueIndex("watch_progress_profile_movie_idx").on(table.profileId, table.movieId), uniqueIndex("watch_progress_profile_episode_idx").on(table.profileId, table.episodeId)]);
+const favorites = sqliteTable("favorites", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	profileId: integer("profile_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+	movieId: integer("movie_id").references(() => movies.id, { onDelete: "cascade" }),
+	showId: integer("show_id").references(() => shows.id, { onDelete: "cascade" }),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [uniqueIndex("favorites_profile_movie_idx").on(table.profileId, table.movieId), uniqueIndex("favorites_profile_show_idx").on(table.profileId, table.showId)]);
+const authConfig = sqliteTable("auth_config", {
+	id: integer("id").primaryKey(),
+	passwordHash: text("password_hash"),
+	updatedAt: integer("updated_at").notNull()
+});
+const sessions$1 = sqliteTable("sessions", {
+	id: text("id").primaryKey(),
+	createdAt: integer("created_at").notNull(),
+	expiresAt: integer("expires_at").notNull(),
+	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") });
 //#endregion
+//#region node_modules/tiny-invariant/dist/esm/tiny-invariant.js
+var import_dayjs_min = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(t, e) {
+		"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+	})(exports, (function() {
+		"use strict";
+		var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = {
+			name: "en",
+			weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+			months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+			ordinal: function(t) {
+				var e = [
+					"th",
+					"st",
+					"nd",
+					"rd"
+				], n = t % 100;
+				return "[" + t + (e[(n - 20) % 10] || e[n] || e[0]) + "]";
+			}
+		}, m = function(t, e, n) {
+			var r = String(t);
+			return !r || r.length >= e ? t : "" + Array(e + 1 - r.length).join(n) + t;
+		}, v = {
+			s: m,
+			z: function(t) {
+				var e = -t.utcOffset(), n = Math.abs(e), r = Math.floor(n / 60), i = n % 60;
+				return (e <= 0 ? "+" : "-") + m(r, 2, "0") + ":" + m(i, 2, "0");
+			},
+			m: function t(e, n) {
+				if (e.date() < n.date()) return -t(n, e);
+				var r = 12 * (n.year() - e.year()) + (n.month() - e.month()), i = e.clone().add(r, c), s = n - i < 0, u = e.clone().add(r + (s ? -1 : 1), c);
+				return +(-(r + (n - i) / (s ? i - u : u - i)) || 0);
+			},
+			a: function(t) {
+				return t < 0 ? Math.ceil(t) || 0 : Math.floor(t);
+			},
+			p: function(t) {
+				return {
+					M: c,
+					y: h,
+					w: o,
+					d: a,
+					D: d,
+					h: u,
+					m: s,
+					s: i,
+					ms: r,
+					Q: f
+				}[t] || String(t || "").toLowerCase().replace(/s$/, "");
+			},
+			u: function(t) {
+				return void 0 === t;
+			}
+		}, g = "en", D = {};
+		D[g] = M;
+		var p = "$isDayjsObject", S = function(t) {
+			return t instanceof _ || !(!t || !t[p]);
+		}, w = function t(e, n, r) {
+			var i;
+			if (!e) return g;
+			if ("string" == typeof e) {
+				var s = e.toLowerCase();
+				D[s] && (i = s), n && (D[s] = n, i = s);
+				var u = e.split("-");
+				if (!i && u.length > 1) return t(u[0]);
+			} else {
+				var a = e.name;
+				D[a] = e, i = a;
+			}
+			return !r && i && (g = i), i || !r && g;
+		}, O = function(t, e) {
+			if (S(t)) return t.clone();
+			var n = "object" == typeof e ? e : {};
+			return n.date = t, n.args = arguments, new _(n);
+		}, b = v;
+		b.l = w, b.i = S, b.w = function(t, e) {
+			return O(t, {
+				locale: e.$L,
+				utc: e.$u,
+				x: e.$x,
+				$offset: e.$offset
+			});
+		};
+		var _ = function() {
+			function M(t) {
+				this.$L = w(t.locale, null, !0), this.parse(t), this.$x = this.$x || t.x || {}, this[p] = !0;
+			}
+			var m = M.prototype;
+			return m.parse = function(t) {
+				this.$d = function(t) {
+					var e = t.date, n = t.utc;
+					if (null === e) return /* @__PURE__ */ new Date(NaN);
+					if (b.u(e)) return /* @__PURE__ */ new Date();
+					if (e instanceof Date) return new Date(e);
+					if ("string" == typeof e && !/Z$/i.test(e)) {
+						var r = e.match($);
+						if (r) {
+							var i = r[2] - 1 || 0, s = (r[7] || "0").substring(0, 3);
+							return n ? new Date(Date.UTC(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s);
+						}
+					}
+					return new Date(e);
+				}(t), this.init();
+			}, m.init = function() {
+				var t = this.$d;
+				this.$y = t.getFullYear(), this.$M = t.getMonth(), this.$D = t.getDate(), this.$W = t.getDay(), this.$H = t.getHours(), this.$m = t.getMinutes(), this.$s = t.getSeconds(), this.$ms = t.getMilliseconds();
+			}, m.$utils = function() {
+				return b;
+			}, m.isValid = function() {
+				return !(this.$d.toString() === l);
+			}, m.isSame = function(t, e) {
+				var n = O(t);
+				return this.startOf(e) <= n && n <= this.endOf(e);
+			}, m.isAfter = function(t, e) {
+				return O(t) < this.startOf(e);
+			}, m.isBefore = function(t, e) {
+				return this.endOf(e) < O(t);
+			}, m.$g = function(t, e, n) {
+				return b.u(t) ? this[e] : this.set(n, t);
+			}, m.unix = function() {
+				return Math.floor(this.valueOf() / 1e3);
+			}, m.valueOf = function() {
+				return this.$d.getTime();
+			}, m.startOf = function(t, e) {
+				var n = this, r = !!b.u(e) || e, f = b.p(t), l = function(t, e) {
+					var i = b.w(n.$u ? Date.UTC(n.$y, e, t) : new Date(n.$y, e, t), n);
+					return r ? i : i.endOf(a);
+				}, $ = function(t, e) {
+					return b.w(n.toDate()[t].apply(n.toDate("s"), (r ? [
+						0,
+						0,
+						0,
+						0
+					] : [
+						23,
+						59,
+						59,
+						999
+					]).slice(e)), n);
+				}, y = this.$W, M = this.$M, m = this.$D, v = "set" + (this.$u ? "UTC" : "");
+				switch (f) {
+					case h: return r ? l(1, 0) : l(31, 11);
+					case c: return r ? l(1, M) : l(0, M + 1);
+					case o:
+						var g = this.$locale().weekStart || 0, D = (y < g ? y + 7 : y) - g;
+						return l(r ? m - D : m + (6 - D), M);
+					case a:
+					case d: return $(v + "Hours", 0);
+					case u: return $(v + "Minutes", 1);
+					case s: return $(v + "Seconds", 2);
+					case i: return $(v + "Milliseconds", 3);
+					default: return this.clone();
+				}
+			}, m.endOf = function(t) {
+				return this.startOf(t, !1);
+			}, m.$set = function(t, e) {
+				var n, o = b.p(t), f = "set" + (this.$u ? "UTC" : ""), l = (n = {}, n[a] = f + "Date", n[d] = f + "Date", n[c] = f + "Month", n[h] = f + "FullYear", n[u] = f + "Hours", n[s] = f + "Minutes", n[i] = f + "Seconds", n[r] = f + "Milliseconds", n)[o], $ = o === a ? this.$D + (e - this.$W) : e;
+				if (o === c || o === h) {
+					var y = this.clone().set(d, 1);
+					y.$d[l]($), y.init(), this.$d = y.set(d, Math.min(this.$D, y.daysInMonth())).$d;
+				} else l && this.$d[l]($);
+				return this.init(), this;
+			}, m.set = function(t, e) {
+				return this.clone().$set(t, e);
+			}, m.get = function(t) {
+				return this[b.p(t)]();
+			}, m.add = function(r, f) {
+				var d, l = this;
+				r = Number(r);
+				var $ = b.p(f), y = function(t) {
+					var e = O(l);
+					return b.w(e.date(e.date() + Math.round(t * r)), l);
+				};
+				if ($ === c) return this.set(c, this.$M + r);
+				if ($ === h) return this.set(h, this.$y + r);
+				if ($ === a) return y(1);
+				if ($ === o) return y(7);
+				var M = (d = {}, d[s] = e, d[u] = n, d[i] = t, d)[$] || 1, m = this.$d.getTime() + r * M;
+				return b.w(m, this);
+			}, m.subtract = function(t, e) {
+				return this.add(-1 * t, e);
+			}, m.format = function(t) {
+				var e = this, n = this.$locale();
+				if (!this.isValid()) return n.invalidDate || l;
+				var r = t || "YYYY-MM-DDTHH:mm:ssZ", i = b.z(this), s = this.$H, u = this.$m, a = this.$M, o = n.weekdays, c = n.months, f = n.meridiem, h = function(t, n, i, s) {
+					return t && (t[n] || t(e, r)) || i[n].slice(0, s);
+				}, d = function(t) {
+					return b.s(s % 12 || 12, t, "0");
+				}, $ = f || function(t, e, n) {
+					var r = t < 12 ? "AM" : "PM";
+					return n ? r.toLowerCase() : r;
+				};
+				return r.replace(y, (function(t, r) {
+					return r || function(t) {
+						switch (t) {
+							case "YY": return String(e.$y).slice(-2);
+							case "YYYY": return b.s(e.$y, 4, "0");
+							case "M": return a + 1;
+							case "MM": return b.s(a + 1, 2, "0");
+							case "MMM": return h(n.monthsShort, a, c, 3);
+							case "MMMM": return h(c, a);
+							case "D": return e.$D;
+							case "DD": return b.s(e.$D, 2, "0");
+							case "d": return String(e.$W);
+							case "dd": return h(n.weekdaysMin, e.$W, o, 2);
+							case "ddd": return h(n.weekdaysShort, e.$W, o, 3);
+							case "dddd": return o[e.$W];
+							case "H": return String(s);
+							case "HH": return b.s(s, 2, "0");
+							case "h": return d(1);
+							case "hh": return d(2);
+							case "a": return $(s, u, !0);
+							case "A": return $(s, u, !1);
+							case "m": return String(u);
+							case "mm": return b.s(u, 2, "0");
+							case "s": return String(e.$s);
+							case "ss": return b.s(e.$s, 2, "0");
+							case "SSS": return b.s(e.$ms, 3, "0");
+							case "Z": return i;
+						}
+						return null;
+					}(t) || i.replace(":", "");
+				}));
+			}, m.utcOffset = function() {
+				return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+			}, m.diff = function(r, d, l) {
+				var $, y = this, M = b.p(d), m = O(r), v = (m.utcOffset() - this.utcOffset()) * e, g = this - m, D = function() {
+					return b.m(y, m);
+				};
+				switch (M) {
+					case h:
+						$ = D() / 12;
+						break;
+					case c:
+						$ = D();
+						break;
+					case f:
+						$ = D() / 3;
+						break;
+					case o:
+						$ = (g - v) / 6048e5;
+						break;
+					case a:
+						$ = (g - v) / 864e5;
+						break;
+					case u:
+						$ = g / n;
+						break;
+					case s:
+						$ = g / e;
+						break;
+					case i:
+						$ = g / t;
+						break;
+					default: $ = g;
+				}
+				return l ? $ : b.a($);
+			}, m.daysInMonth = function() {
+				return this.endOf(c).$D;
+			}, m.$locale = function() {
+				return D[this.$L];
+			}, m.locale = function(t, e) {
+				if (!t) return this.$L;
+				var n = this.clone(), r = w(t, e, !0);
+				return r && (n.$L = r), n;
+			}, m.clone = function() {
+				return b.w(this.$d, this);
+			}, m.toDate = function() {
+				return new Date(this.valueOf());
+			}, m.toJSON = function() {
+				return this.isValid() ? this.toISOString() : null;
+			}, m.toISOString = function() {
+				return this.$d.toISOString();
+			}, m.toString = function() {
+				return this.$d.toUTCString();
+			}, M;
+		}(), k = _.prototype;
+		return O.prototype = k, [
+			["$ms", r],
+			["$s", i],
+			["$m", s],
+			["$H", u],
+			["$W", a],
+			["$M", c],
+			["$y", h],
+			["$D", d]
+		].forEach((function(t) {
+			k[t[1]] = function(e) {
+				return this.$g(e, t[0], t[1]);
+			};
+		})), O.extend = function(t, e) {
+			return t.$i || (t(e, _, O), t.$i = !0), O;
+		}, O.locale = w, O.isDayjs = S, O.unix = function(t) {
+			return O(1e3 * t);
+		}, O.en = D[g], O.Ls = D, O.p = {}, O;
+	}));
+})))(), 1);
+var isProduction = process.env.NODE_ENV === "production";
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+	if (condition) return;
+	if (isProduction) throw new Error(prefix);
+	var provided = typeof message === "function" ? message() : message;
+	var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+	throw new Error(value);
+}
+//#endregion
+//#region src/api/routes/auth.ts
+const scryptAsync = promisify(scrypt);
+const sessionCookieName = "jukebox_session";
+const rateLimitWindowMs = 900 * 1e3;
+const rateLimitBuckets = /* @__PURE__ */ new Map();
+function clientIp(headers) {
+	const forwarded = headers.get("x-forwarded-for");
+	if (forwarded) {
+		const first = forwarded.split(",")[0]?.trim();
+		if (first) return first;
+	}
+	return headers.get("x-real-ip") ?? "unknown";
+}
+function checkRateLimit(ip) {
+	const now = Date.now();
+	const cutoff = now - rateLimitWindowMs;
+	const entry = rateLimitBuckets.get(ip) ?? { attempts: [] };
+	entry.attempts = entry.attempts.filter((time) => time > cutoff);
+	if (entry.attempts.length >= 5) {
+		const retryAfterMs = (entry.attempts[0] ?? now) + rateLimitWindowMs - now;
+		const retryAfterSeconds = Math.max(1, Math.ceil(retryAfterMs / 1e3));
+		rateLimitBuckets.set(ip, entry);
+		return {
+			allowed: false,
+			retryAfterSeconds
+		};
+	}
+	rateLimitBuckets.set(ip, entry);
+	return {
+		allowed: true,
+		retryAfterSeconds: 0
+	};
+}
+function recordFailedAttempt(ip) {
+	const entry = rateLimitBuckets.get(ip) ?? { attempts: [] };
+	entry.attempts.push(Date.now());
+	rateLimitBuckets.set(ip, entry);
+}
+function clearAttempts(ip) {
+	rateLimitBuckets.delete(ip);
+}
+async function loadAuthConfig() {
+	const [existing] = await db.select().from(authConfig).where(eq(authConfig.id, 1)).limit(1);
+	if (existing) return existing;
+	const [created] = await db.insert(authConfig).values({
+		id: 1,
+		passwordHash: null,
+		updatedAt: Date.now()
+	}).returning();
+	invariant(created, "Failed to initialize auth config.");
+	return created;
+}
+const scryptKeyLength = 64;
+async function hashPassword(password) {
+	const salt = randomBytes(16);
+	const derived = await scryptAsync(password, salt, scryptKeyLength);
+	return `scrypt$${salt.toString("base64")}$${derived.toString("base64")}`;
+}
+async function verifyPassword(password, stored) {
+	const parts = stored.split("$");
+	if (parts.length !== 3 || parts[0] !== "scrypt") return false;
+	try {
+		const salt = Buffer.from(parts[1] ?? "", "base64");
+		const expected = Buffer.from(parts[2] ?? "", "base64");
+		const derived = await scryptAsync(password, salt, expected.length);
+		if (derived.length !== expected.length) return false;
+		return timingSafeEqual(derived, expected);
+	} catch {
+		return false;
+	}
+}
+function createSessionToken() {
+	return randomBytes(32).toString("base64url");
+}
+async function createSession(userAgent) {
+	const now = (0, import_dayjs_min.default)();
+	const token = createSessionToken();
+	await db.insert(sessions$1).values({
+		id: token,
+		createdAt: now.valueOf(),
+		expiresAt: now.add(30, "day").valueOf(),
+		lastSeenAt: now.valueOf(),
+		userAgent
+	});
+	return token;
+}
+async function deleteAllSessions() {
+	await db.delete(sessions$1);
+}
+async function deleteSession(id) {
+	await db.delete(sessions$1).where(eq(sessions$1.id, id));
+}
+function sessionCookieOptions() {
+	return {
+		httpOnly: true,
+		maxAge: 720 * 60 * 60,
+		path: "/",
+		sameSite: "Lax",
+		secure: process.env.NODE_ENV === "production"
+	};
+}
+const authRoutes = new Hono();
+authRoutes.get("/status", async (context) => {
+	if (!((await loadAuthConfig()).passwordHash !== null)) return context.json({
+		enabled: false,
+		authenticated: true
+	});
+	const cookie = getCookie(context, sessionCookieName);
+	if (!cookie) return context.json({
+		enabled: true,
+		authenticated: false
+	});
+	const [session] = await db.select().from(sessions$1).where(eq(sessions$1.id, cookie)).limit(1);
+	const authenticated = session !== void 0 && session.expiresAt > Date.now();
+	return context.json({
+		enabled: true,
+		authenticated
+	});
+});
+authRoutes.post("/login", async (context) => {
+	const ip = clientIp(context.req.raw.headers);
+	const limit = checkRateLimit(ip);
+	if (!limit.allowed) {
+		const minutes = Math.ceil(limit.retryAfterSeconds / 60);
+		context.header("Retry-After", String(limit.retryAfterSeconds));
+		return context.json({ error: { message: `Too many attempts. Try again in ${minutes} ${minutes === 1 ? "minute" : "minutes"}.` } }, 429);
+	}
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		return context.json({ error: { message: "Invalid request body." } }, 400);
+	}
+	const password = typeof body.password === "string" ? body.password : "";
+	if (password.length === 0) return context.json({ error: { message: "Incorrect password." } }, 401);
+	const config = await loadAuthConfig();
+	if (config.passwordHash === null) return context.json({ error: { message: "Password login is disabled on this server." } }, 400);
+	if (!await verifyPassword(password, config.passwordHash)) {
+		recordFailedAttempt(ip);
+		return context.json({ error: { message: "Incorrect password." } }, 401);
+	}
+	clearAttempts(ip);
+	setCookie(context, sessionCookieName, await createSession(context.req.header("user-agent") ?? null), sessionCookieOptions());
+	return context.body(null, 204);
+});
+authRoutes.post("/logout", async (context) => {
+	const token = getCookie(context, sessionCookieName);
+	if (token) await deleteSession(token);
+	deleteCookie(context, sessionCookieName, { path: "/" });
+	return context.body(null, 204);
+});
+authRoutes.post("/password", async (context) => {
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		return context.json({ error: { message: "Invalid request body." } }, 400);
+	}
+	const newPassword = typeof body.newPassword === "string" ? body.newPassword : "";
+	const currentPassword = typeof body.currentPassword === "string" ? body.currentPassword : "";
+	const config = await loadAuthConfig();
+	if (config.passwordHash !== null) {
+		if (!await verifyPassword(currentPassword, config.passwordHash ?? "")) return context.json({ error: { message: "Current password is incorrect." } }, 401);
+	}
+	if (newPassword.length === 0) {
+		await db.update(authConfig).set({
+			passwordHash: null,
+			updatedAt: Date.now()
+		}).where(eq(authConfig.id, 1));
+		await deleteAllSessions();
+		deleteCookie(context, sessionCookieName, { path: "/" });
+		return context.json({ enabled: false });
+	}
+	if (newPassword.length < 8) return context.json({ error: { message: `Choose a password of at least 8 characters.` } }, 400);
+	const hash = await hashPassword(newPassword);
+	await db.update(authConfig).set({
+		passwordHash: hash,
+		updatedAt: Date.now()
+	}).where(eq(authConfig.id, 1));
+	await deleteAllSessions();
+	setCookie(context, sessionCookieName, await createSession(context.req.header("user-agent") ?? null), sessionCookieOptions());
+	return context.json({ enabled: true });
+});
+//#endregion
+//#region src/api/middleware/auth.ts
+const lastSeenThrottleMs = 60 * 1e3;
+let lastSweepAt = 0;
+const sweepIntervalMs = 300 * 1e3;
+async function sweepExpiredSessions(now) {
+	if (now - lastSweepAt < sweepIntervalMs) return;
+	lastSweepAt = now;
+	await db.delete(sessions$1).where(lt(sessions$1.expiresAt, now));
+}
+const authMiddleware = createMiddleware(async (context, next) => {
+	const pathname = new URL(context.req.url).pathname;
+	if (pathname.startsWith("/api/auth") || pathname.startsWith("/api/setup")) return next();
+	const [config] = await db.select().from(authConfig).where(eq(authConfig.id, 1)).limit(1);
+	if (!config || config.passwordHash === null) return next();
+	const token = getCookie(context, sessionCookieName);
+	if (!token) return context.json({ error: { message: "Authentication required." } }, 401);
+	const [session] = await db.select().from(sessions$1).where(eq(sessions$1.id, token)).limit(1);
+	const now = Date.now();
+	await sweepExpiredSessions(now);
+	if (!session || session.expiresAt <= now) {
+		if (session) await db.delete(sessions$1).where(eq(sessions$1.id, session.id));
+		return context.json({ error: { message: "Your session has expired. Please sign in again." } }, 401);
+	}
+	if (now - session.lastSeenAt > lastSeenThrottleMs) await db.update(sessions$1).set({ lastSeenAt: now }).where(eq(sessions$1.id, session.id));
+	return next();
+});
+//#endregion
+//#region src/api/middleware/profile.ts
+const profileCookieName = "jukebox_profile_id";
+const oneYearSeconds = 3600 * 24 * 365;
+function setProfileCookie(context, profileId) {
+	setCookie(context, profileCookieName, String(profileId), {
+		httpOnly: true,
+		maxAge: oneYearSeconds,
+		path: "/",
+		sameSite: "Lax"
+	});
+}
+async function readProfileFromCookie(rawCookieValue) {
+	if (!rawCookieValue) return null;
+	const parsedId = parseInt(rawCookieValue, 10);
+	if (isNaN(parsedId)) return null;
+	const [profile] = await db.select().from(profiles).where(eq(profiles.id, parsedId)).limit(1);
+	return profile ?? null;
+}
+async function fallbackProfile() {
+	const [latest] = await db.select().from(profiles).orderBy(desc(profiles.createdAt)).limit(1);
+	if (latest) return latest;
+	const now = /* @__PURE__ */ new Date();
+	const [created] = await db.insert(profiles).values({
+		name: "Default",
+		emoji: "🍿",
+		createdAt: now
+	}).returning();
+	if (!created) throw new Error("Failed to create default profile");
+	return created;
+}
+const profileMiddleware = createMiddleware(async (context, next) => {
+	const fromCookie = await readProfileFromCookie(getCookie(context, profileCookieName));
+	const profile = fromCookie ?? await fallbackProfile();
+	if (!fromCookie || fromCookie.id !== profile.id) setProfileCookie(context, profile.id);
+	context.set("profileId", profile.id);
+	await next();
+});
+//#endregion
 //#region src/api/routes/episode-progress.ts
 const episodeProgressRoutes = new Hono();
 episodeProgressRoutes.get("/show/:showId", async (context) => {
+	const profileId = context.get("profileId");
 	const showId = parseInt(context.req.param("showId"), 10);
 	if (isNaN(showId)) return context.json({ error: { message: "Invalid show ID" } }, 400);
 	const episodeIds = (await db.select({ id: episodes.id }).from(episodes).where(eq(episodes.showId, showId))).map((episode) => episode.id);
@@ -6735,7 +7526,7 @@ episodeProgressRoutes.get("/show/:showId", async (context) => {
 		currentTime: watchProgress.currentTime,
 		duration: watchProgress.duration,
 		updatedAt: watchProgress.updatedAt
-	}).from(watchProgress).where(and(inArray(watchProgress.episodeId, episodeIds), gt(watchProgress.currentTime, 0)));
+	}).from(watchProgress).where(and(eq(watchProgress.profileId, profileId), inArray(watchProgress.episodeId, episodeIds), gt(watchProgress.currentTime, 0)));
 	const progressMap = {};
 	for (const row of progressRows) if (row.episodeId !== null) progressMap[row.episodeId] = {
 		currentTime: row.currentTime,
@@ -6745,9 +7536,10 @@ episodeProgressRoutes.get("/show/:showId", async (context) => {
 	return context.json(progressMap);
 });
 episodeProgressRoutes.get("/:episodeId", async (context) => {
+	const profileId = context.get("profileId");
 	const episodeId = parseInt(context.req.param("episodeId"), 10);
 	if (isNaN(episodeId)) return context.json({ error: { message: "Invalid episode ID" } }, 400);
-	const [progress] = await db.select().from(watchProgress).where(eq(watchProgress.episodeId, episodeId)).limit(1);
+	const [progress] = await db.select().from(watchProgress).where(and(eq(watchProgress.profileId, profileId), eq(watchProgress.episodeId, episodeId))).limit(1);
 	if (!progress) return context.json({
 		currentTime: 0,
 		duration: null
@@ -6758,18 +7550,20 @@ episodeProgressRoutes.get("/:episodeId", async (context) => {
 	});
 });
 episodeProgressRoutes.put("/:episodeId", async (context) => {
+	const profileId = context.get("profileId");
 	const episodeId = parseInt(context.req.param("episodeId"), 10);
 	if (isNaN(episodeId)) return context.json({ error: { message: "Invalid episode ID" } }, 400);
 	const body = await context.req.json();
 	if (typeof body.currentTime !== "number") return context.json({ error: { message: "currentTime is required" } }, 400);
-	const [existing] = await db.select().from(watchProgress).where(eq(watchProgress.episodeId, episodeId)).limit(1);
+	const [existing] = await db.select().from(watchProgress).where(and(eq(watchProgress.profileId, profileId), eq(watchProgress.episodeId, episodeId))).limit(1);
 	const now = /* @__PURE__ */ new Date();
 	if (existing) await db.update(watchProgress).set({
 		currentTime: Math.floor(body.currentTime),
 		duration: body.duration ? Math.floor(body.duration) : existing.duration,
 		updatedAt: now
-	}).where(eq(watchProgress.episodeId, episodeId));
+	}).where(eq(watchProgress.id, existing.id));
 	else await db.insert(watchProgress).values({
+		profileId,
 		episodeId,
 		currentTime: Math.floor(body.currentTime),
 		duration: body.duration ? Math.floor(body.duration) : null,
@@ -6778,17 +7572,6 @@ episodeProgressRoutes.put("/:episodeId", async (context) => {
 	return context.json({ success: true });
 });
 //#endregion
-//#region node_modules/tiny-invariant/dist/esm/tiny-invariant.js
-var isProduction = process.env.NODE_ENV === "production";
-var prefix = "Invariant failed";
-function invariant(condition, message) {
-	if (condition) return;
-	if (isProduction) throw new Error(prefix);
-	var provided = typeof message === "function" ? message() : message;
-	var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
-	throw new Error(value);
-}
-//#endregion
 //#region src/api/routes/episode-stream.ts
 const mimeTypes$1 = {
 	".avi": "video/x-msvideo",
@@ -6853,38 +7636,352 @@ helloRoutes.put("/", (c) => c.json({
 }));
 helloRoutes.get("/:name", (c) => c.json({ message: `Hello, ${c.req.param("name")}!` }));
 //#endregion
-//#region src/api/routes/library.ts
-const libraryRoutes = new Hono();
-libraryRoutes.get("/movies", async (c) => {
-	const movies$2 = await db.select().from(movies).orderBy(movies.title);
-	return c.json(movies$2);
-});
-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]);
-});
+//#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/api/routes/progress.ts
-const progressRoutes = new Hono();
-progressRoutes.get("/continue-watching", async (context) => {
-	const inProgressFilter = and(gt(watchProgress.currentTime, 0), sql`(${watchProgress.duration} IS NULL OR ${watchProgress.currentTime} < ${watchProgress.duration} * 0.9)`);
-	const movieResults = await db.select({
-		currentTime: watchProgress.currentTime,
-		duration: watchProgress.duration,
-		movie: movies,
-		updatedAt: watchProgress.updatedAt
-	}).from(watchProgress).innerJoin(movies, eq(watchProgress.movieId, movies.id)).where(inProgressFilter);
-	const episodeResults = await db.select({
-		currentTime: watchProgress.currentTime,
-		duration: watchProgress.duration,
-		episode: episodes,
-		show: shows,
-		updatedAt: watchProgress.updatedAt
-	}).from(watchProgress).innerJoin(episodes, eq(watchProgress.episodeId, episodes.id)).innerJoin(shows, eq(episodes.showId, shows.id)).where(inProgressFilter);
-	const movies$1 = movieResults.map((result) => ({
+//#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) => {
+	const movies$3 = await db.select().from(movies).orderBy(movies.title);
+	return c.json(movies$3);
+});
+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) 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
+const progressRoutes = new Hono();
+progressRoutes.get("/continue-watching", async (context) => {
+	const profileId = context.get("profileId");
+	const inProgressFilter = and(eq(watchProgress.profileId, profileId), gt(watchProgress.currentTime, 0), sql`(${watchProgress.duration} IS NULL OR ${watchProgress.currentTime} < ${watchProgress.duration} * 0.9)`);
+	const movieResults = await db.select({
+		currentTime: watchProgress.currentTime,
+		duration: watchProgress.duration,
+		movie: movies,
+		updatedAt: watchProgress.updatedAt
+	}).from(watchProgress).innerJoin(movies, eq(watchProgress.movieId, movies.id)).where(inProgressFilter);
+	const episodeResults = await db.select({
+		currentTime: watchProgress.currentTime,
+		duration: watchProgress.duration,
+		episode: episodes,
+		show: shows,
+		updatedAt: watchProgress.updatedAt
+	}).from(watchProgress).innerJoin(episodes, eq(watchProgress.episodeId, episodes.id)).innerJoin(shows, eq(episodes.showId, shows.id)).where(inProgressFilter);
+	const movies$2 = movieResults.map((result) => ({
 		...result,
 		type: "movie"
 	}));
@@ -6892,13 +7989,14 @@ progressRoutes.get("/continue-watching", async (context) => {
 		...result,
 		type: "episode"
 	}));
-	const combined = [...movies$1, ...episodes$2].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 20);
+	const combined = [...movies$2, ...episodes$2].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 20);
 	return context.json(combined);
 });
 progressRoutes.get("/:movieId", async (c) => {
+	const profileId = c.get("profileId");
 	const movieId = parseInt(c.req.param("movieId"), 10);
 	if (isNaN(movieId)) return c.json({ error: { message: "Invalid movie ID" } }, 400);
-	const [progress] = await db.select().from(watchProgress).where(eq(watchProgress.movieId, movieId)).limit(1);
+	const [progress] = await db.select().from(watchProgress).where(and(eq(watchProgress.profileId, profileId), eq(watchProgress.movieId, movieId))).limit(1);
 	if (!progress) return c.json({
 		currentTime: 0,
 		duration: null
@@ -6909,18 +8007,20 @@ progressRoutes.get("/:movieId", async (c) => {
 	});
 });
 progressRoutes.put("/:movieId", async (c) => {
+	const profileId = c.get("profileId");
 	const movieId = parseInt(c.req.param("movieId"), 10);
 	if (isNaN(movieId)) return c.json({ error: { message: "Invalid movie ID" } }, 400);
 	const body = await c.req.json();
 	if (typeof body.currentTime !== "number") return c.json({ error: { message: "currentTime is required" } }, 400);
-	const [existing] = await db.select().from(watchProgress).where(eq(watchProgress.movieId, movieId)).limit(1);
+	const [existing] = await db.select().from(watchProgress).where(and(eq(watchProgress.profileId, profileId), eq(watchProgress.movieId, movieId))).limit(1);
 	const now = /* @__PURE__ */ new Date();
 	if (existing) await db.update(watchProgress).set({
 		currentTime: Math.floor(body.currentTime),
 		duration: body.duration ? Math.floor(body.duration) : existing.duration,
 		updatedAt: now
-	}).where(eq(watchProgress.movieId, movieId));
+	}).where(eq(watchProgress.id, existing.id));
 	else await db.insert(watchProgress).values({
+		profileId,
 		movieId,
 		currentTime: Math.floor(body.currentTime),
 		duration: body.duration ? Math.floor(body.duration) : null,
@@ -7060,15 +8160,551 @@ var streamSSE = (c, cb, onError) => {
 	return c.newResponse(stream.responseReadable);
 };
 //#endregion
+//#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
+		}
+	});
+	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/settings.ts
+const tmdbApiKeySettingKey = "tmdbApiKey";
+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
+		}
+	});
+}
+/**
+* Resolve the TMDB API key using the dual-source strategy:
+*
+* 1. Prefer the value stored in the `settings` table.
+* 2. Fall back to `~/.jukebox/config.json` for backward compatibility on the
+*    first boot after upgrading. Copy the JSON value into the DB once so
+*    subsequent lookups only touch the DB.
+*
+* Returns null when neither source has a key configured.
+*/
+async function getTmdbApiKey(database = db) {
+	const stored = await getSetting(tmdbApiKeySettingKey, database);
+	if (stored !== null && stored.length > 0) return stored;
+	const legacyKey = getConfig()?.tmdbApiKey ?? null;
+	if (legacyKey !== null && legacyKey.length > 0) {
+		await setSetting(tmdbApiKeySettingKey, legacyKey, database);
+		return legacyKey;
+	}
+	return null;
+}
+/**
+* Persist the TMDB API key to the DB. Also mirror the value to the JSON
+* config file so rollbacks to an older server build keep working.
+*/
+async function setTmdbApiKey(apiKey, database = db) {
+	await setSetting(tmdbApiKeySettingKey, apiKey, database);
+	try {
+		await saveConfig({ tmdbApiKey: apiKey });
+	} catch (error) {
+		log.warn("Couldn't mirror TMDB key to config.json — rollback safety is degraded. Check permissions on ~/.jukebox/.", error);
+	}
+}
+//#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;
+async function getApiKey() {
+	const apiKey = await getTmdbApiKey() ?? 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 apiKey = await getApiKey();
 	const params = new URLSearchParams({
 		api_key: apiKey,
 		query: title
@@ -7079,14 +8715,14 @@ async function searchMovie(title, year) {
 	return (await response.json()).results;
 }
 async function getMovieDetails(tmdbId) {
-	const apiKey = getApiKey();
+	const apiKey = await 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 await response.json();
 }
 async function getMovieVideos(tmdbId) {
-	const apiKey = getApiKey();
+	const apiKey = await 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}`);
@@ -7107,7 +8743,7 @@ function getTrailerUrl(videos) {
 }
 async function fetchMovieMetadata(title, year) {
 	try {
-		getApiKey();
+		await getApiKey();
 	} catch {
 		return null;
 	}
@@ -7130,7 +8766,7 @@ async function fetchMovieMetadata(title, year) {
 	};
 }
 async function searchShow(title, year) {
-	const apiKey = getApiKey();
+	const apiKey = await getApiKey();
 	const params = new URLSearchParams({
 		api_key: apiKey,
 		query: title
@@ -7141,14 +8777,14 @@ async function searchShow(title, year) {
 	return (await response.json()).results;
 }
 async function getShowDetails(tmdbId) {
-	const apiKey = getApiKey();
+	const apiKey = await 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 getSeasonDetails(tmdbId, seasonNumber) {
-	const apiKey = getApiKey();
+	const apiKey = await 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}`);
@@ -7156,7 +8792,7 @@ async function getSeasonDetails(tmdbId, seasonNumber) {
 }
 async function fetchShowMetadata(title, year) {
 	try {
-		getApiKey();
+		await getApiKey();
 	} catch {
 		return null;
 	}
@@ -7179,7 +8815,7 @@ async function fetchShowMetadata(title, year) {
 }
 async function fetchSeasonMetadata(tmdbId, seasonNumber) {
 	try {
-		getApiKey();
+		await getApiKey();
 	} catch {
 		return null;
 	}
@@ -7199,106 +8835,73 @@ async function fetchSeasonMetadata(tmdbId, seasonNumber) {
 	};
 }
 //#endregion
-//#region src/services/filename-parser.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 }
-*/
-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
-	};
-}
+//#region src/services/subtitle-sync.ts
 /**
-* Extract year from a filename if present
+* 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 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();
@@ -7309,9 +8912,12 @@ 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];
+			movieId = movie.id;
 			let tmdbData = {};
 			if (!movie.tmdbId) {
 				console.log(`  Fetching TMDB metadata for: ${title}`);
@@ -7369,7 +8975,7 @@ async function scanLibrary(libraryPath, onProgress) {
 				backdropPath: metadata?.backdropPath ?? 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,
@@ -7377,6 +8983,7 @@ async function scanLibrary(libraryPath, onProgress) {
 				updated
 			});
 		}
+		if (movieId !== null) await syncSubtitlesForMovie(movieId, discoveredSubtitles);
 		console.log(`  Found: ${title}`);
 	}
 	return {
@@ -7387,7 +8994,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",
@@ -7403,7 +9010,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;
@@ -7497,18 +9104,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 {
@@ -7516,10 +9111,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);
@@ -7534,7 +9135,8 @@ async function scanEpisodesInDirectory(directory) {
 			extension,
 			seasonNumber: parsed.seasonNumber,
 			episodeNumber: parsed.episodeNumber,
-			title: parsed.title
+			title: parsed.title,
+			subtitleSiblings
 		});
 	}
 	return episodes;
@@ -7694,7 +9296,9 @@ async function scanShowLibrary(libraryPath, onProgress) {
 				const episodeTitle = tmdbEpisode?.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,
@@ -7726,7 +9330,7 @@ async function scanShowLibrary(libraryPath, onProgress) {
 						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,
@@ -7734,6 +9338,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)`);
@@ -7745,85 +9353,746 @@ async function scanShowLibrary(libraryPath, onProgress) {
 	};
 }
 //#endregion
-//#region src/api/routes/scan.ts
-const scanRoutes = new Hono();
-scanRoutes.get("/libraries", async (context) => {
-	const libraries$3 = await db.select().from(libraries);
-	return context.json(libraries$3.map((library) => ({
-		id: library.id,
-		name: library.name,
-		path: library.path,
-		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);
-	return streamSSE(context, async (stream) => {
+//#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;
-		for (let i = 0; i < libraries$2.length; i++) {
-			const library = libraries$2[i];
-			if (!library) continue;
-			await stream.writeSSE({
-				event: "library-start",
-				data: JSON.stringify({ index: i })
-			});
-			try {
+		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) => {
-					await stream.writeSSE({
-						event: "file-scanned",
-						data: JSON.stringify({
-							index: i,
-							...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
 					});
 				};
-				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) {
-				await stream.writeSSE({
-					event: "library-error",
-					data: JSON.stringify({
-						error: error instanceof Error ? error.message : "Unknown error",
-						index: i
-					})
-				});
+				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
+					});
+				}
 			}
-		}
-		await stream.writeSSE({
-			event: "scan-complete",
-			data: JSON.stringify({
+			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,
-				found: totalFound,
+				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) => {
+	const libraries$3 = await db.select().from(libraries);
+	return context.json(libraries$3.map((library) => ({
+		id: library.id,
+		name: library.name,
+		path: library.path,
+		type: library.type
+	})));
+});
+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) => {
+		const onLibraryStart = (event) => {
+			stream.writeSSE({
+				event: "library-start",
+				data: JSON.stringify(event)
+			});
+		};
+		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: "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_path AS poster_path,
+      movies.backdrop_path AS backdrop_path
+    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) => ({
+		backdropPath: row.backdrop_path,
+		id: row.id,
+		overview: row.overview,
+		posterPath: row.poster_path,
+		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_path AS poster_path,
+      shows.backdrop_path AS backdrop_path
+    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) => ({
+		backdropPath: row.backdrop_path,
+		id: row.id,
+		overview: row.overview,
+		posterPath: row.poster_path,
+		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_path AS still_path,
+      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 ?? "",
+		stillPath: row.still_path,
+		title: row.title
+	}));
+}
+//#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 tmdbConfigurationUrl = "https://api.themoviedb.org/3/configuration";
+const reservedKeys = new Set([tmdbApiKeySettingKey, scanScheduleSettingKey]);
+const reservedKeyRoute = {
+	[tmdbApiKeySettingKey]: "/api/settings/tmdb-key",
+	[scanScheduleSettingKey]: "/api/settings/scan-schedule"
+};
+async function verifyTmdbKey(apiKey) {
+	try {
+		return (await fetch(`${tmdbConfigurationUrl}?api_key=${encodeURIComponent(apiKey)}`)).ok;
+	} catch {
+		return false;
+	}
+}
+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("/tmdb-key", async (context) => {
+	const apiKey = await getTmdbApiKey();
+	return context.json({
+		configured: apiKey !== null && apiKey.length > 0,
+		apiKey: apiKey ?? ""
+	});
+});
+settingsRoutes.put("/tmdb-key", async (context) => {
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		return context.json({ error: { message: "Invalid request body." } }, 400);
+	}
+	const apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
+	if (apiKey.length === 0) return context.json({ error: { message: "TMDB API key is required. Get one at themoviedb.org/settings/api." } }, 400);
+	if (!await verifyTmdbKey(apiKey)) return context.json({ error: { message: "Couldn't save TMDB key — the key wasn't accepted by TMDB. Check it at themoviedb.org/settings/api." } }, 400);
+	await setTmdbApiKey(apiKey);
+	return context.json({ configured: true });
+});
+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 apiKey = await getTmdbApiKey();
 	const libraries$1 = await db.select().from(libraries);
 	return context.json({
-		config: config ? { tmdbApiKey: config.tmdbApiKey } : null,
-		hasApiKey: config?.tmdbApiKey !== void 0 && config.tmdbApiKey !== "",
+		config: apiKey !== null ? { tmdbApiKey: apiKey } : null,
+		hasApiKey: apiKey !== null && apiKey !== "",
 		libraries: libraries$1.map((library) => ({
 			id: library.id,
 			name: library.name,
@@ -7838,7 +10107,7 @@ 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 setTmdbApiKey(body.tmdbApiKey);
 	await db.delete(libraries);
 	const now = /* @__PURE__ */ new Date();
 	for (const library of body.libraries) await db.insert(libraries).values({
@@ -7850,6 +10119,146 @@ setupRoutes.post("/complete", async (context) => {
 	return context.json({ success: true });
 });
 //#endregion
+//#region src/api/routes/profiles.ts
+const profileRoutes = new Hono();
+profileRoutes.get("/", async (context) => {
+	const profiles$1 = await db.select().from(profiles).orderBy(desc(profiles.createdAt));
+	return context.json(profiles$1);
+});
+profileRoutes.get("/active", async (context) => {
+	const profileId = context.get("profileId");
+	const [profile] = await db.select().from(profiles).where(eq(profiles.id, profileId)).limit(1);
+	if (!profile) return context.json({ error: { message: "Active profile not found" } }, 404);
+	return context.json(profile);
+});
+profileRoutes.post("/", async (context) => {
+	const body = await context.req.json();
+	const name = body.name?.trim();
+	const emoji = body.emoji?.trim();
+	if (!name || !emoji) return context.json({ error: { message: "name and emoji are required" } }, 400);
+	const now = /* @__PURE__ */ new Date();
+	try {
+		const [created] = await db.insert(profiles).values({
+			name,
+			emoji,
+			createdAt: now
+		}).returning();
+		return context.json(created, 201);
+	} catch (error) {
+		const message = error instanceof Error && error.message.includes("UNIQUE") ? "A profile with that name already exists" : "Failed to create profile";
+		return context.json({ error: { message } }, 400);
+	}
+});
+profileRoutes.patch("/:id", async (context) => {
+	const id = parseInt(context.req.param("id"), 10);
+	if (isNaN(id)) return context.json({ error: { message: "Invalid profile id" } }, 400);
+	const body = await context.req.json();
+	const updates = {};
+	if (typeof body.name === "string" && body.name.trim()) updates.name = body.name.trim();
+	if (typeof body.emoji === "string" && body.emoji.trim()) updates.emoji = body.emoji.trim();
+	if (Object.keys(updates).length === 0) return context.json({ error: { message: "Nothing to update" } }, 400);
+	try {
+		const [updated] = await db.update(profiles).set(updates).where(eq(profiles.id, id)).returning();
+		if (!updated) return context.json({ error: { message: "Profile not found" } }, 404);
+		return context.json(updated);
+	} catch (error) {
+		const message = error instanceof Error && error.message.includes("UNIQUE") ? "A profile with that name already exists" : "Failed to update profile";
+		return context.json({ error: { message } }, 400);
+	}
+});
+profileRoutes.delete("/:id", async (context) => {
+	const id = parseInt(context.req.param("id"), 10);
+	if (isNaN(id)) return context.json({ error: { message: "Invalid profile id" } }, 400);
+	const all = await db.select({ id: profiles.id }).from(profiles);
+	if (all.length <= 1) return context.json({ error: { message: "Cannot delete the last remaining profile" } }, 400);
+	await db.delete(profiles).where(eq(profiles.id, id));
+	if (context.get("profileId") === id) {
+		const next = all.find((profile) => profile.id !== id);
+		if (next) setProfileCookie(context, next.id);
+	}
+	return context.json({ success: true });
+});
+profileRoutes.post("/:id/activate", async (context) => {
+	const id = parseInt(context.req.param("id"), 10);
+	if (isNaN(id)) return context.json({ error: { message: "Invalid profile id" } }, 400);
+	const [profile] = await db.select().from(profiles).where(eq(profiles.id, id)).limit(1);
+	if (!profile) return context.json({ error: { message: "Profile not found" } }, 404);
+	setProfileCookie(context, profile.id);
+	return context.json(profile);
+});
+//#endregion
+//#region src/api/routes/favorites.ts
+const favoriteRoutes = new Hono();
+favoriteRoutes.get("/", async (context) => {
+	const profileId = context.get("profileId");
+	const movieFavorites = await db.select({
+		createdAt: favorites.createdAt,
+		movie: movies
+	}).from(favorites).innerJoin(movies, eq(favorites.movieId, movies.id)).where(eq(favorites.profileId, profileId)).orderBy(desc(favorites.createdAt));
+	const showFavorites = await db.select({
+		createdAt: favorites.createdAt,
+		show: shows
+	}).from(favorites).innerJoin(shows, eq(favorites.showId, shows.id)).where(eq(favorites.profileId, profileId)).orderBy(desc(favorites.createdAt));
+	const movies$1 = movieFavorites.map((row) => ({
+		...row,
+		type: "movie"
+	}));
+	const shows$2 = showFavorites.map((row) => ({
+		...row,
+		type: "show"
+	}));
+	const combined = [...movies$1, ...shows$2].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+	return context.json(combined);
+});
+favoriteRoutes.get("/status", async (context) => {
+	const profileId = context.get("profileId");
+	const movieIdParam = context.req.query("movieId");
+	const showIdParam = context.req.query("showId");
+	if (movieIdParam) {
+		const movieId = parseInt(movieIdParam, 10);
+		if (isNaN(movieId)) return context.json({ error: { message: "Invalid movie ID" } }, 400);
+		const [favorite] = await db.select({ id: favorites.id }).from(favorites).where(and(eq(favorites.profileId, profileId), eq(favorites.movieId, movieId))).limit(1);
+		return context.json({ favorite: !!favorite });
+	}
+	if (showIdParam) {
+		const showId = parseInt(showIdParam, 10);
+		if (isNaN(showId)) return context.json({ error: { message: "Invalid show ID" } }, 400);
+		const [favorite] = await db.select({ id: favorites.id }).from(favorites).where(and(eq(favorites.profileId, profileId), eq(favorites.showId, showId))).limit(1);
+		return context.json({ favorite: !!favorite });
+	}
+	return context.json({ error: { message: "movieId or showId required" } }, 400);
+});
+favoriteRoutes.post("/", async (context) => {
+	const profileId = context.get("profileId");
+	const body = await context.req.json();
+	if (typeof body.movieId !== "number" && typeof body.showId !== "number" || typeof body.movieId === "number" && typeof body.showId === "number") return context.json({ error: { message: "Provide exactly one of movieId or showId" } }, 400);
+	const now = /* @__PURE__ */ new Date();
+	try {
+		await db.insert(favorites).values({
+			profileId,
+			movieId: body.movieId ?? null,
+			showId: body.showId ?? null,
+			createdAt: now
+		});
+	} catch (error) {
+		if (!(error instanceof Error) || !error.message.includes("UNIQUE")) throw error;
+	}
+	return context.json({ success: true });
+});
+favoriteRoutes.delete("/", async (context) => {
+	const profileId = context.get("profileId");
+	const body = await context.req.json();
+	if (typeof body.movieId === "number") {
+		await db.delete(favorites).where(and(eq(favorites.profileId, profileId), eq(favorites.movieId, body.movieId)));
+		return context.json({ success: true });
+	}
+	if (typeof body.showId === "number") {
+		await db.delete(favorites).where(and(eq(favorites.profileId, profileId), eq(favorites.showId, body.showId)));
+		return context.json({ success: true });
+	}
+	return context.json({ error: { message: "movieId or showId required" } }, 400);
+});
+//#endregion
 //#region src/api/routes/shows.ts
 const showRoutes = new Hono();
 showRoutes.get("/", async (context) => {
@@ -7871,8 +10280,35 @@ 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,
+		subtitles: subtitles$1
+	});
+});
+showRoutes.get("/:showId/next-episode", async (context) => {
+	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 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 (!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({
+		episode: nextEpisode,
 		show
 	});
 });
@@ -7952,23 +10388,341 @@ 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),
+	info: (...args) => console.info("[transcode]", ...args),
+	warn: (...args) => console.warn("[transcode]", ...args)
+};
+const reapIdleMs = 1800 * 1e3;
+const reaperIntervalMs = 300 * 1e3;
+const sessions = /* @__PURE__ */ new Map();
+function sessionKey(fileId, profileId) {
+	return `${fileId}:${profileId}`;
+}
+function safeDirectoryName(fileId, profileId) {
+	return `${fileId}__${profileId}`;
+}
+function getTranscodeRoot() {
+	return path.join(os.tmpdir(), "jukebox-transcode");
+}
+function waitForPlaylist(playlistPath, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const startedAt = Date.now();
+		const check = () => {
+			if (existsSync(playlistPath)) {
+				resolve();
+				return;
+			}
+			if (Date.now() - startedAt > timeoutMs) {
+				reject(/* @__PURE__ */ new Error("Couldn't prepare this file for casting. Check that ffmpeg is installed."));
+				return;
+			}
+			setTimeout(check, 200);
+		};
+		check();
+	});
+}
+function startTranscode({ fileId, filePath, profileId, spawnImplementation }) {
+	const key = sessionKey(fileId, profileId);
+	const existing = sessions.get(key);
+	if (existing) {
+		existing.lastAccessedAt = Date.now();
+		return existing;
+	}
+	const tempDir = path.join(getTranscodeRoot(), safeDirectoryName(fileId, profileId));
+	mkdirSync(tempDir, { recursive: true });
+	const playlistPath = path.join(tempDir, "index.m3u8");
+	const args = [
+		"-i",
+		filePath,
+		"-c:v",
+		"copy",
+		"-c:a",
+		"aac",
+		"-ac",
+		"2",
+		"-f",
+		"hls",
+		"-hls_time",
+		"6",
+		"-hls_list_size",
+		"0",
+		"-hls_segment_filename",
+		path.join(tempDir, "segment-%03d.ts"),
+		playlistPath
+	];
+	const spawner = spawnImplementation ?? spawn;
+	let ffmpegProcess;
+	try {
+		ffmpegProcess = spawner("ffmpeg", args, { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+	} catch (error) {
+		logger.error(`Failed to spawn ffmpeg for ${fileId}:`, error);
+		throw new Error("Couldn't prepare this file for casting. Check that ffmpeg is installed.", { cause: error });
+	}
+	ffmpegProcess.on("error", (error) => {
+		logger.error(`ffmpeg process error for ${fileId}:`, error);
+	});
+	ffmpegProcess.on("exit", (code) => {
+		logger.info(`ffmpeg exited for ${fileId} with code ${code}`);
+	});
+	const readyPromise = waitForPlaylist(playlistPath, 3e4);
+	const session = {
+		fileId,
+		ffmpegProcess,
+		lastAccessedAt: Date.now(),
+		playlistPath,
+		tempDir,
+		readyPromise
+	};
+	sessions.set(key, session);
+	return session;
+}
+function stopSession(key) {
+	const session = sessions.get(key);
+	if (!session) return;
+	if (session.ffmpegProcess && session.ffmpegProcess.exitCode === null) try {
+		session.ffmpegProcess.kill("SIGTERM");
+	} catch (error) {
+		logger.warn(`Failed to kill ffmpeg for ${session.fileId}:`, error);
+	}
+	try {
+		rmSync(session.tempDir, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		logger.warn(`Failed to remove temp dir ${session.tempDir}:`, error);
+	}
+	sessions.delete(key);
+}
+function reapIdleSessions(now = Date.now()) {
+	for (const [key, session] of sessions.entries()) if (now - session.lastAccessedAt > reapIdleMs) {
+		logger.info(`Reaping idle transcode session ${key}`);
+		stopSession(key);
+	}
+}
+if (typeof setInterval !== "undefined" && process.env.NODE_ENV !== "test") setInterval(() => reapIdleSessions(), reaperIntervalMs).unref?.();
+async function resolveFile(fileId) {
+	if (fileId.startsWith("episode-")) {
+		const episodeId = parseInt(fileId.slice(8), 10);
+		if (isNaN(episodeId)) return null;
+		const [episode] = await db.select().from(episodes).where(eq(episodes.id, episodeId)).limit(1);
+		if (!episode) return null;
+		return { filePath: episode.filePath };
+	}
+	if (fileId.startsWith("movie-")) {
+		const movieId = parseInt(fileId.slice(6), 10);
+		if (isNaN(movieId)) return null;
+		const [movie] = await db.select().from(movies).where(eq(movies.id, movieId)).limit(1);
+		if (!movie) return null;
+		return { filePath: movie.filePath };
+	}
+	return null;
+}
+const transcodeRoutes = new Hono();
+transcodeRoutes.get("/:fileId/index.m3u8", async (context) => {
+	const fileId = context.req.param("fileId");
+	const profileIdRaw = context.req.header("x-jukebox-profile-id") ?? "0";
+	const profileId = parseInt(profileIdRaw, 10);
+	const resolved = await resolveFile(fileId);
+	if (!resolved) return context.json({ error: { message: "File not found" } }, 404);
+	if (!existsSync(resolved.filePath)) return context.json({ error: { message: "Video file not found" } }, 404);
+	try {
+		const session = startTranscode({
+			fileId,
+			filePath: resolved.filePath,
+			profileId: isNaN(profileId) ? 0 : profileId
+		});
+		session.lastAccessedAt = Date.now();
+		await session.readyPromise;
+		const playlistStream = createReadStream(session.playlistPath);
+		const webStream = Readable.toWeb(playlistStream);
+		return new Response(webStream, { headers: {
+			"Content-Type": "application/vnd.apple.mpegurl",
+			"Cache-Control": "no-store"
+		} });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Couldn't prepare this file for casting. Check that ffmpeg is installed.";
+		return context.json({ error: { message } }, 500);
+	}
+});
+transcodeRoutes.get("/:fileId/:segment", async (context) => {
+	const fileId = context.req.param("fileId");
+	const segment = context.req.param("segment");
+	const profileIdRaw = context.req.header("x-jukebox-profile-id") ?? "0";
+	const profileId = parseInt(profileIdRaw, 10);
+	const key = sessionKey(fileId, isNaN(profileId) ? 0 : profileId);
+	const session = sessions.get(key);
+	if (!session) return context.json({ error: { message: "Transcode session not found" } }, 404);
+	if (!/^segment-\d+\.ts$/.test(segment)) return context.json({ error: { message: "Invalid segment" } }, 400);
+	const segmentPath = path.join(session.tempDir, segment);
+	const startedAt = Date.now();
+	while (!existsSync(segmentPath) && Date.now() - startedAt < 15e3) await new Promise((resolve) => setTimeout(resolve, 200));
+	if (!existsSync(segmentPath)) return context.json({ error: { message: "Segment not ready" } }, 404);
+	session.lastAccessedAt = Date.now();
+	const size = statSync(segmentPath).size;
+	const nodeStream = createReadStream(segmentPath);
+	const webStream = Readable.toWeb(nodeStream);
+	return new Response(webStream, { headers: {
+		"Content-Type": "video/mp2t",
+		"Content-Length": String(size),
+		"Cache-Control": "no-store"
+	} });
+});
+try {
+	const root = getTranscodeRoot();
+	if (existsSync(root)) for (const entry of readdirSync(root)) rmSync(path.join(root, entry), {
+		recursive: true,
+		force: true
+	});
+} catch (error) {
+	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) => {
+	const profileId = context.get("profileId");
+	const episodeProgressRows = await db.select({
+		currentTime: watchProgress.currentTime,
+		duration: watchProgress.duration,
+		episode: episodes,
+		updatedAt: watchProgress.updatedAt
+	}).from(watchProgress).innerJoin(episodes, eq(watchProgress.episodeId, episodes.id)).where(eq(watchProgress.profileId, profileId)).orderBy(desc(watchProgress.updatedAt));
+	const latestRowByShow = /* @__PURE__ */ new Map();
+	for (const row of episodeProgressRows) if (!latestRowByShow.has(row.episode.showId)) latestRowByShow.set(row.episode.showId, row);
+	const items = [];
+	for (const [showId, row] of latestRowByShow.entries()) {
+		if (!((row.duration && row.duration > 0 ? row.currentTime / row.duration : 0) >= .9)) continue;
+		const laterEpisodes = (await db.select().from(episodes).where(eq(episodes.showId, showId)).orderBy(episodes.seasonNumber, episodes.episodeNumber)).filter((candidate) => {
+			if (candidate.seasonNumber > row.episode.seasonNumber) return true;
+			if (candidate.seasonNumber < row.episode.seasonNumber) return false;
+			return candidate.episodeNumber > row.episode.episodeNumber;
+		});
+		if (laterEpisodes.length === 0) continue;
+		const laterIds = new Set(laterEpisodes.map((candidate) => candidate.id));
+		const laterProgress = episodeProgressRows.filter((progressRow) => progressRow.episode.id !== row.episode.id && laterIds.has(progressRow.episode.id));
+		const progressByEpisodeId = /* @__PURE__ */ new Map();
+		for (const progressRow of laterProgress) progressByEpisodeId.set(progressRow.episode.id, {
+			currentTime: progressRow.currentTime,
+			duration: progressRow.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) continue;
+		const [show] = await db.select().from(shows).where(eq(shows.id, showId)).limit(1);
+		if (!show) continue;
+		items.push({
+			episode: nextEpisode,
+			show,
+			lastWatchedAt: row.updatedAt.toISOString()
+		});
+	}
+	items.sort((a, b) => new Date(b.lastWatchedAt).getTime() - new Date(a.lastWatchedAt).getTime());
+	return context.json(items.slice(0, 20));
+});
+//#endregion
 //#region src/api/index.ts
 const app = new Hono();
-app.use("*", logger());
+app.use("*", logger$1());
+app.use("/api/*", authMiddleware);
+app.use("/api/*", profileMiddleware);
 app.onError((error, context) => {
 	console.error("Unhandled error:", error);
 	const message = error instanceof Error ? error.message : "An unexpected error occurred";
 	return context.json({ error: { message } }, 500);
 });
+app.route("/api/auth", authRoutes);
 app.route("/api/hello", helloRoutes);
 app.route("/api/library/shows", showRoutes);
+app.route("/api/library/up-next", upNextRoutes);
 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/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));
 const clientDir = path.resolve(__dirname$1, "../client");
@@ -8035,7 +10789,8 @@ function readPackageVersion() {
 const version = readPackageVersion();
 let viteServer = null;
 if (isDevelopment) {
-	viteServer = await createServer$1({
+	const { createServer } = await import("vite");
+	viteServer = await createServer({
 		configFile: "./vite.config.ts",
 		server: {
 			port: vitePort,
@@ -8045,6 +10800,8 @@ if (isDevelopment) {
 	await viteServer.listen();
 	setupViteProxy(vitePort);
 } else setupStaticServing();
+await scanManager.recoverInterruptedJobs();
+await scheduler.start();
 const server = serve({
 	fetch: app.fetch,
 	port
@@ -8070,6 +10827,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);