dsh-any-background 0.2.8 → 0.2.10

package/lib/index.js

@@ -27,10 +27,14 @@ const VIDEO_ROUTE = "/dsh-any-background/video";
 const UPLOAD_ROUTE = "/dsh-any-background/video/upload";
 const WALLPAPER_ROUTE = "/dsh-any-background/wallpaper";
 const WALLPAPER_UPLOAD_ROUTE = "/dsh-any-background/wallpaper/upload";
+const FONT_ROUTE = "/dsh-any-background/font";
+const FONT_UPLOAD_ROUTE = "/dsh-any-background/font/upload";
 const UPLOAD_TMP = "wallpaper.upload.tmp";
 const VIDEO_UPLOAD_TMP = "video.upload.tmp";
+const FONT_UPLOAD_TMP = "font.upload.tmp";
 const WALLPAPER_UPLOAD_MAX = 104857600;
 const VIDEO_UPLOAD_MAX = 2147483648;
+const FONT_UPLOAD_MAX = 104857600;
 const WALLPAPER_FETCH_MAX = 26214400;
 const WALLPAPER_FETCH_TIMEOUT = 2e4;
 const VIDEO_FETCH_MAX = 2147483648;
@@ -54,28 +58,100 @@ const VIDEO_CANDIDATES = [
 	"wallpaper.mkv",
 	"wallpaper.video"
 ];
+/** Font slot: one font owns the slot, named by format like the video slot. */
+function fontFileName(mime) {
+	switch (mime) {
+		case "font/woff2": return "font.woff2";
+		case "font/woff": return "font.woff";
+		case "font/otf": return "font.otf";
+		case "font/ttf": return "font.ttf";
+		default: return "font.ttf";
+	}
+}
+const FONT_CANDIDATES = [
+	"font.woff2",
+	"font.woff",
+	"font.otf",
+	"font.ttf"
+];
+/** Sniff a font's container format from its leading magic bytes (null when the
+*  bytes are not a recognized font — uploads are rejected rather than stored). */
+function sniffFontMime(buf) {
+	if (buf.length >= 4 && buf[0] === 119 && buf[1] === 79 && buf[2] === 70 && buf[3] === 50) return "font/woff2";
+	if (buf.length >= 4 && buf[0] === 119 && buf[1] === 79 && buf[2] === 70 && buf[3] === 70) return "font/woff";
+	if (buf.length >= 4 && buf[0] === 79 && buf[1] === 84 && buf[2] === 84 && buf[3] === 79) return "font/otf";
+	if (buf.length >= 4 && buf[0] === 0 && buf[1] === 1 && buf[2] === 0 && buf[3] === 0) return "font/ttf";
+	return null;
+}
 const DEFAULT_CONFIG = {
 	color: null,
 	opacities: {
-		bg: .85,
-		sidebar: .93,
-		card: 1,
-		input: 1
+		bg: .5,
+		sidebar: .5,
+		card: .5,
+		input: .5
 	},
 	blurs: {
-		bg: 0,
-		sidebar: 0,
-		card: 0,
-		settings: 0,
-		chat: 0,
-		trajectory: 0,
-		input: 0,
-		panel: 0,
-		produced: 0
+		bg: 30,
+		sidebar: 30,
+		card: 30,
+		settings: 30,
+		chat: 30,
+		trajectory: 30,
+		input: 30,
+		panel: 30,
+		produced: 30
 	},
-	settingsOpacity: 1,
+	strokes: {
+		bg: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		sidebar: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		card: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		settings: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		chat: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		trajectory: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		input: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		panel: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		produced: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		}
+	},
+	settingsOpacity: .5,
 	wallpaperOpacity: 1,
-	blur: 0,
+	blur: 30,
 	bgState: {
 		zoom: 1,
 		x: 0,
@@ -93,12 +169,14 @@ const DEFAULT_CONFIG = {
 	backgroundType: "image",
 	bgMode: "fit",
 	videoMime: null,
+	fontMime: null,
+	fontEnabled: true,
 	generatedBg: null,
 	regenerateOnReload: false,
-	chatTextOpacity: 0,
-	trajectoryOpacity: 1,
-	panelOpacity: 1,
-	producedOpacity: 1,
+	chatTextOpacity: .5,
+	trajectoryOpacity: .5,
+	panelOpacity: .5,
+	producedOpacity: .5,
 	profiles: [],
 	rotation: {
 		enabled: false,
@@ -123,6 +201,7 @@ const dataDir = () => dshHomePath(DATA_DIR);
 const configPath = () => dshHomePath(DATA_DIR, CONFIG_FILE);
 const wallpaperPath = () => dshHomePath(DATA_DIR, WALLPAPER_FILE);
 const videoPathFor = (mime) => dshHomePath(DATA_DIR, videoFileName(mime));
+const fontPathFor = (mime) => dshHomePath(DATA_DIR, fontFileName(mime));
 const exists = async (p) => {
 	try {
 		await access(p);
@@ -162,6 +241,43 @@ async function findVideoFile() {
 function clamp(n, lo, hi, def) {
 	return typeof n === "number" && isFinite(n) ? Math.min(hi, Math.max(lo, n)) : def;
 }
+/** Locate the stored font: the recorded MIME decides the expected name; stray
+*  files from a lost config write are adopted via rename (mirrors the video
+*  slot's recovery). */
+async function findFontFile() {
+	const mime = (await readConfig()).fontMime ?? "font/ttf";
+	const expected = fontPathFor(mime);
+	if (await exists(expected)) return {
+		path: expected,
+		mime
+	};
+	for (const name of FONT_CANDIDATES) {
+		const p = dshHomePath(DATA_DIR, name);
+		if (!await exists(p)) continue;
+		const foundMime = mimeForFontFile(name);
+		try {
+			await rename(p, expected);
+			return {
+				path: expected,
+				mime: foundMime
+			};
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+function mimeForFontFile(name) {
+	switch (name) {
+		case "font.woff2": return "font/woff2";
+		case "font.woff": return "font/woff";
+		case "font.otf": return "font/otf";
+		default: return "font/ttf";
+	}
+}
+async function fontUrl() {
+	return await findFontFile() ? FONT_ROUTE : null;
+}
 function normalizeBgState(s) {
 	return {
 		zoom: clamp(s.zoom, .1, 10, 1),
@@ -172,6 +288,40 @@ function normalizeBgState(s) {
 	};
 }
 /** Coerce an unknown persisted value into a valid ThemeConfig, falling back per-field. */
+const STROKE_GROUPS = [
+	"bg",
+	"sidebar",
+	"card",
+	"settings",
+	"chat",
+	"trajectory",
+	"input",
+	"panel",
+	"produced"
+];
+const STROKE_COLOR_KEYS = [
+	"auto",
+	"gray",
+	"black",
+	"white",
+	"theme",
+	"custom"
+];
+const HEX_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+function normalizeStroke(raw) {
+	const s = raw ?? {};
+	return {
+		width: clamp(s.width, 0, 4, 0),
+		color: STROKE_COLOR_KEYS.includes(s.color) ? s.color : "auto",
+		customColor: typeof s.customColor === "string" && HEX_RE.test(s.customColor) ? s.customColor : "#808080"
+	};
+}
+function normalizeStrokes(raw) {
+	const s = raw ?? {};
+	const out = {};
+	for (const k of STROKE_GROUPS) out[k] = normalizeStroke(s[k]);
+	return out;
+}
 function normalizeConfig(raw) {
 	const r = raw ?? {};
 	const c = r.color;
@@ -220,6 +370,7 @@ function normalizeConfig(raw) {
 			input: clamp(ops.input, 0, 1, DEFAULT_CONFIG.opacities.input)
 		},
 		blurs,
+		strokes: normalizeStrokes(r.strokes),
 		settingsOpacity: clamp(r.settingsOpacity, 0, 1, DEFAULT_CONFIG.settingsOpacity),
 		wallpaperOpacity: clamp(r.wallpaperOpacity, 0, 1, DEFAULT_CONFIG.wallpaperOpacity),
 		blur: clamp(r.blur, 0, 60, DEFAULT_CONFIG.blur),
@@ -228,6 +379,8 @@ function normalizeConfig(raw) {
 		backgroundType: bgType,
 		bgMode,
 		videoMime: typeof r.videoMime === "string" ? r.videoMime : null,
+		fontMime: typeof r.fontMime === "string" ? r.fontMime : null,
+		fontEnabled: typeof r.fontEnabled === "boolean" ? r.fontEnabled : DEFAULT_CONFIG.fontEnabled,
 		generatedBg,
 		regenerateOnReload: typeof r.regenerateOnReload === "boolean" ? r.regenerateOnReload : DEFAULT_CONFIG.regenerateOnReload,
 		chatTextOpacity: clamp(r.chatTextOpacity, 0, 1, DEFAULT_CONFIG.chatTextOpacity),
@@ -311,6 +464,7 @@ function normalizeProfileAppearance(raw) {
 			input: clamp(ops.input, 0, 1, DEFAULT_CONFIG.opacities.input)
 		},
 		blurs,
+		strokes: normalizeStrokes(a.strokes),
 		settingsOpacity: clamp(a.settingsOpacity, 0, 1, DEFAULT_CONFIG.settingsOpacity),
 		wallpaperOpacity: clamp(a.wallpaperOpacity, 0, 1, DEFAULT_CONFIG.wallpaperOpacity),
 		blur: clamp(a.blur, 0, 60, DEFAULT_CONFIG.blur),
@@ -382,12 +536,41 @@ async function ensureDir() {
 		console.warn(`dsh-any-background: cannot create data dir "${dataDir()}"`, e);
 	}
 }
+let configCacheKey = null;
+let configCacheValue = null;
+function dropConfigCache() {
+	configCacheKey = null;
+	configCacheValue = null;
+}
 async function readConfig() {
 	await ensureDir();
+	const file = configPath();
+	let text;
+	let key;
 	try {
-		const raw = await readFile(configPath(), "utf8");
-		return normalizeConfig(JSON.parse(raw));
+		const st = await stat(file);
+		key = {
+			mtimeMs: st.mtimeMs,
+			size: st.size
+		};
+		if (configCacheKey !== null && configCacheValue !== null && configCacheKey.mtimeMs === key.mtimeMs && configCacheKey.size === key.size) return configCacheValue;
+		text = await readFile(file, "utf8");
 	} catch {
+		dropConfigCache();
+		return { ...DEFAULT_CONFIG };
+	}
+	try {
+		const parsed = normalizeConfig(JSON.parse(text));
+		configCacheKey = key;
+		configCacheValue = parsed;
+		return parsed;
+	} catch (e) {
+		try {
+			const into = `${file}.corrupt-${Date.now()}`;
+			await rename(file, into);
+			console.warn(`dsh-any-background: theme-config.json was corrupt, archived to "${into}" and reset to defaults`, e);
+		} catch {}
+		dropConfigCache();
 		return { ...DEFAULT_CONFIG };
 	}
 }
@@ -406,7 +589,11 @@ function warnUnknownConfigKeys(raw, normalized) {
 		if (known.has(key) || LEGACY_CONFIG_KEYS.has(key)) continue;
 		warn(key);
 	}
-	for (const group of ["blurs", "opacities"]) {
+	for (const group of [
+		"blurs",
+		"opacities",
+		"strokes"
+	]) {
 		const got = r[group];
 		if (got === null || typeof got !== "object") continue;
 		const have = new Set(Object.keys(normalized[group]));
@@ -415,13 +602,19 @@ function warnUnknownConfigKeys(raw, normalized) {
 }
 async function writeConfig(config) {
 	await ensureDir();
+	const tmp = `${configPath()}.tmp`;
 	try {
 		const normalized = normalizeConfig(config);
 		warnUnknownConfigKeys(config, normalized);
-		await writeFile(configPath(), JSON.stringify(normalized, null, 2), "utf8");
+		await writeFile(tmp, JSON.stringify(normalized, null, 2), "utf8");
+		await rename(tmp, configPath());
+		dropConfigCache();
 		return true;
 	} catch (e) {
 		console.error(`dsh-any-background: failed to write "${CONFIG_FILE}"`, e);
+		try {
+			await rm(tmp, { force: true });
+		} catch {}
 		return false;
 	}
 }
@@ -460,6 +653,17 @@ function sniffImageMime(buf) {
 	if (buf.length >= 12 && buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) return "image/webp";
 	return "image/jpeg";
 }
+/** True when the leading bytes are a container the serve route knows how to
+*  sniff. The Content-Type only reflects what the server claims; validating the
+*  bytes themselves rejects a mislabeled or hostile payload with a clear error
+*  instead of persisting a file that renders as a broken image. */
+function isImageBytes(buf) {
+	if (buf.length >= 4 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) return true;
+	if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return true;
+	if (buf.length >= 6 && buf[0] === 71 && buf[1] === 73 && buf[2] === 70) return true;
+	if (buf.length >= 12 && buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) return true;
+	return false;
+}
 /** Download a wallpaper from a network URL and persist it into the local
 *  wallpaper.jpg slot (replacing whatever was stored), so type switches and
 *  rotation keep working through the single active slot. The response carries
@@ -532,6 +736,10 @@ async function writeWallpaperFromUrl(url) {
 			error: "read failed"
 		};
 	}
+	if (!isImageBytes(buf)) return {
+		ok: false,
+		error: "not an image"
+	};
 	await ensureDir();
 	try {
 		await writeFile(wallpaperPath(), buf);
@@ -753,21 +961,28 @@ async function writeVideoFromUrl(url) {
 		const out = createWriteStream(tmp);
 		let received = 0;
 		let failed = false;
-		const fail = () => {
-			if (failed) return;
-			failed = true;
-			out.destroy();
-			rm(tmp, { force: true });
-		};
 		const nodeStream = Readable.fromWeb(res.body);
 		let idle = null;
+		const clearIdle = () => {
+			if (idle !== null) {
+				clearTimeout(idle);
+				idle = null;
+			}
+		};
 		const pokeIdle = () => {
-			if (idle) clearTimeout(idle);
+			clearIdle();
 			idle = setTimeout(() => {
 				nodeStream.destroy();
 				fail();
 			}, VIDEO_FETCH_IDLE_TIMEOUT);
 		};
+		const fail = () => {
+			if (failed) return;
+			failed = true;
+			clearIdle();
+			out.destroy();
+			rmWhenClosed(out, tmp);
+		};
 		nodeStream.on("data", (chunk) => {
 			pokeIdle();
 			received += chunk.byteLength;
@@ -776,10 +991,7 @@ async function writeVideoFromUrl(url) {
 				fail();
 			}
 		});
-		nodeStream.on("end", () => {
-			if (idle) clearTimeout(idle);
-			idle = null;
-		});
+		nodeStream.on("end", clearIdle);
 		nodeStream.on("aborted", fail);
 		nodeStream.on("error", fail);
 		out.on("error", fail);
@@ -843,6 +1055,37 @@ async function writeVideo(dataUrl) {
 		return false;
 	}
 }
+/** Drop a partial upload's temp file once its sink is really closed. Windows
+*  refuses to unlink a file that still has an open handle, so removing it in the
+*  same tick as `out.destroy()` silently fails and leaves the aborted transfer
+*  on disk (up to the full limit) until some later upload overwrites it. */
+function rmWhenClosed(out, tmp) {
+	const drop = () => {
+		rm(tmp, { force: true });
+	};
+	if (out.closed === true) drop();
+	else out.once("close", drop);
+}
+/** Reject an oversized upload with a real status and tear the transfer down.
+*  The bare req.destroy()+fail() path left the client holding a network error
+*  with no way to tell "too large" from "connection died". The body is machine
+*  readable (`error` + the enforced `limit`) so the panel can phrase the
+*  refusal in the user's own language, with `message` kept for logs. */
+function rejectOversizedUpload(req, res, fail, limit) {
+	try {
+		res.writeHead(413, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "too large",
+			limit,
+			message: `too large (limit ${limit})`
+		}));
+	} catch {}
+	fail();
+	try {
+		req.destroy();
+	} catch {}
+}
 /** Stream the stored video: correct MIME, no caching, Range answers so the
 *  browser can seek (snapshot capture does). */
 async function serveVideo(req, res) {
@@ -946,16 +1189,14 @@ async function handleVideoUpload(req, res) {
 			if (failed) return;
 			failed = true;
 			out.destroy();
-			rm(tmp, { force: true });
+			rmWhenClosed(out, tmp);
 		};
 		req.on("aborted", fail);
 		req.on("error", fail);
 		req.on("data", (chunk) => {
+			if (failed) return;
 			received += chunk.byteLength;
-			if (received > VIDEO_UPLOAD_MAX) {
-				req.destroy();
-				fail();
-			}
+			if (received > VIDEO_UPLOAD_MAX) rejectOversizedUpload(req, res, fail, "2 GB");
 		});
 		out.on("error", () => {
 			fail();
@@ -1068,7 +1309,7 @@ async function handleWallpaperUpload(req, res) {
 			if (failed) return;
 			failed = true;
 			out.destroy();
-			rm(tmp, { force: true });
+			rmWhenClosed(out, tmp);
 		};
 		req.on("aborted", fail);
 		req.on("error", fail);
@@ -1080,11 +1321,9 @@ async function handleWallpaperUpload(req, res) {
 			} catch {}
 		});
 		req.on("data", (chunk) => {
+			if (failed) return;
 			received += chunk.byteLength;
-			if (received > WALLPAPER_UPLOAD_MAX) {
-				req.destroy();
-				fail();
-			}
+			if (received > WALLPAPER_UPLOAD_MAX) rejectOversizedUpload(req, res, fail, "100 MB");
 		});
 		req.pipe(out);
 		out.on("finish", async () => {
@@ -1123,6 +1362,162 @@ async function handleWallpaperUpload(req, res) {
 		} catch {}
 	}
 }
+/** Stream the stored custom font: sniffed MIME, no caching (uploads replace
+*  the file in place). Fonts need no Range support — the browser fetches once. */
+async function serveFont(req, res) {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "font route only serves GET/HEAD"
+		}));
+		return;
+	}
+	try {
+		const found = await findFontFile();
+		if (found === null) {
+			res.writeHead(404);
+			res.end("no custom font stored");
+			return;
+		}
+		const st = await stat(found.path);
+		res.writeHead(200, {
+			"Content-Type": found.mime,
+			"Content-Length": st.size,
+			"Cache-Control": "no-store"
+		});
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		createReadStream(found.path).pipe(res);
+	} catch (e) {
+		console.error("dsh-any-background: failed to serve the custom font", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
+/** Accept a raw font upload (POST): pipe the body into a temp file, sniff the
+*  container format from its magic bytes (rejecting anything that is not a
+*  recognizable font), then rename it into the format-derived slot and record
+*  the MIME in the config so serve/find resolve immediately. */
+async function handleFontUpload(req, res) {
+	if (req.method !== "POST") {
+		res.writeHead(405);
+		res.end();
+		return;
+	}
+	try {
+		await ensureDir();
+		const tmp = dshHomePath(DATA_DIR, FONT_UPLOAD_TMP);
+		const out = createWriteStream(tmp);
+		let received = 0;
+		let failed = false;
+		const fail = () => {
+			if (failed) return;
+			failed = true;
+			out.destroy();
+			rmWhenClosed(out, tmp);
+		};
+		req.on("aborted", fail);
+		req.on("error", fail);
+		out.on("error", () => {
+			fail();
+			try {
+				res.writeHead(500);
+				res.end();
+			} catch {}
+		});
+		req.on("data", (chunk) => {
+			if (failed) return;
+			received += chunk.byteLength;
+			if (received > FONT_UPLOAD_MAX) rejectOversizedUpload(req, res, fail, "100 MB");
+		});
+		req.pipe(out);
+		out.on("finish", async () => {
+			if (failed) return;
+			try {
+				if (received === 0) {
+					fail();
+					res.writeHead(400, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						ok: false,
+						error: "empty upload"
+					}));
+					return;
+				}
+				const mime = sniffFontMime(await new Promise((resolve, reject) => {
+					const chunks = [];
+					const s = createReadStream(tmp, {
+						start: 0,
+						end: 15
+					});
+					s.on("data", (c) => chunks.push(c));
+					s.on("end", () => resolve(Buffer.concat(chunks)));
+					s.on("error", reject);
+				}));
+				if (mime === null) {
+					fail();
+					res.writeHead(415, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						ok: false,
+						error: "not a font (expected ttf/otf/woff/woff2)"
+					}));
+					return;
+				}
+				const target = fontPathFor(mime);
+				for (const name of FONT_CANDIDATES) {
+					const p = dshHomePath(DATA_DIR, name);
+					if (p !== target) await rm(p, { force: true });
+				}
+				await rm(target, { force: true });
+				await rename(tmp, target);
+				const cfg = await readConfig();
+				if (cfg.fontMime !== mime) {
+					cfg.fontMime = mime;
+					await writeConfig(cfg);
+				}
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					ok: true,
+					fontUrl: FONT_ROUTE,
+					mime
+				}));
+			} catch (e) {
+				console.error("dsh-any-background: failed to finalize the font upload", e);
+				rm(tmp, { force: true });
+				try {
+					res.writeHead(500);
+					res.end();
+				} catch {}
+			}
+		});
+	} catch (e) {
+		console.error("dsh-any-background: failed to accept the font upload", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
+/** Remove every stored font variant and clear the recorded MIME. */
+async function removeFontFile() {
+	try {
+		for (const name of FONT_CANDIDATES) await rm(dshHomePath(DATA_DIR, name), { force: true });
+		await rm(dshHomePath(DATA_DIR, FONT_UPLOAD_TMP), { force: true });
+		const cfg = await readConfig();
+		if (cfg.fontMime !== null) {
+			cfg.fontMime = null;
+			await writeConfig(cfg);
+		}
+		return true;
+	} catch (e) {
+		console.error("dsh-any-background: failed to remove the custom font", e);
+		return false;
+	}
+}
 const NS = "dshAnyBackground";
 const RPC_CHANNEL = "/dsh-any-background";
 const RPC_BODY_MAX = 314572800;
@@ -1142,8 +1537,7 @@ function isoWeekKey(d) {
 *  old one never reaches the screen. The client's maybeRotate stays as a
 *  fallback and skips when this already advanced (the `rotated` flag). */
 async function advanceRotationIfDue() {
-	const cfg = await readConfig();
-	const rot = cfg.rotation;
+	const rot = (await readConfig()).rotation;
 	if (!rot.enabled || rot.items.length === 0) return false;
 	const now = /* @__PURE__ */ new Date();
 	const last = rot.lastRotate !== null ? new Date(rot.lastRotate) : null;
@@ -1161,12 +1555,14 @@ async function advanceRotationIfDue() {
 		console.error("dsh-any-background: failed to advance the rotation pool", e);
 		return false;
 	}
-	cfg.rotation = {
-		...rot,
-		current: idx,
-		lastRotate: now.toISOString()
-	};
-	if (!await writeConfig(cfg)) return false;
+	if (!await writeConfig({
+		...await readConfig(),
+		rotation: {
+			...rot,
+			current: idx,
+			lastRotate: now.toISOString()
+		}
+	})) return false;
 	return true;
 }
 /** Dispatch one decoded RPC method to the matching persistence routine and
@@ -1177,13 +1573,18 @@ async function handleRpcMethod(endpoint, payload) {
 		switch (method) {
 			case "read": {
 				const rotated = await advanceRotationIfDue();
+				const config = await readConfig();
+				const firstRun = !await exists(configPath());
+				if (firstRun) await writeConfig(config);
 				return {
 					ok: true,
 					value: {
-						config: await readConfig(),
+						config,
 						wallpaperUrl: await wallpaperServeUrl(),
 						videoUrl: await videoUrl(),
-						rotated
+						fontUrl: await fontUrl(),
+						rotated,
+						firstRun
 					}
 				};
 			}
@@ -1219,6 +1620,10 @@ async function handleRpcMethod(endpoint, payload) {
 				ok: true,
 				value: await handleRotationSet(payload)
 			};
+			case "removeFont": return {
+				ok: true,
+				value: await removeFontFile()
+			};
 			default: return {
 				ok: false,
 				error: {
@@ -1263,6 +1668,22 @@ function apply(ctx) {
 					}));
 					return;
 				}
+				const declaredLen = Number(req.headers["content-length"] ?? "");
+				if (Number.isFinite(declaredLen) && declaredLen > RPC_BODY_MAX) {
+					res.writeHead(413, {
+						"Content-Type": "application/json",
+						connection: "close"
+					});
+					res.end(JSON.stringify({
+						ok: false,
+						error: {
+							code: "dsh-any-background/too-large",
+							message: `body exceeds ${RPC_BODY_MAX} bytes; uploads must use the binary routes`,
+							details: {}
+						}
+					}));
+					return;
+				}
 				const pathname = new URL(req.url ?? "/", "http://dsh.internal").pathname;
 				const endpoint = pathname.startsWith(`${RPC_CHANNEL}/`) ? pathname.slice(20) : void 0;
 				if (endpoint === void 0 || endpoint.length === 0) {
@@ -1364,7 +1785,17 @@ function apply(ctx) {
 			path: WALLPAPER_UPLOAD_ROUTE,
 			handler: fenceUpload(handleWallpaperUpload)
 		}), "dsh-any-background: wallpaper upload route");
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "prefix",
+			path: FONT_ROUTE,
+			handler: serveFont
+		}), "dsh-any-background: font route");
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "exact",
+			path: FONT_UPLOAD_ROUTE,
+			handler: fenceUpload(handleFontUpload)
+		}), "dsh-any-background: font upload route");
 	});
 }
 //#endregion
-export { apply, inject, name };
+export { DEFAULT_CONFIG, apply, inject, name };