From ea1e876355a6f94193640ae3564746daaf08f9ce Mon Sep 17 00:00:00 2001
From: gilnett <gilles.deschuyteneer@gmail.com>
Date: Thu, 8 Oct 2026 18:17:36 +0200
Subject: [PATCH 1/6] feat(desktop): implement upload speed test and health
 check for instant mode

---
 .../src/components/NetworkHealthIndicator.tsx | 133 ++++++++
 .../routes/(window-chrome)/new-main/index.tsx |  19 ++
 apps/desktop/src/utils/network-health.test.ts |  75 +++++
 apps/desktop/src/utils/network-health.ts      | 306 ++++++++++++++++++
 apps/web/app/api/desktop/[...route]/health.ts |  66 ++++
 apps/web/app/api/desktop/[...route]/route.ts  |   2 +
 6 files changed, 601 insertions(+)
 create mode 100644 apps/desktop/src/components/NetworkHealthIndicator.tsx
 create mode 100644 apps/desktop/src/utils/network-health.test.ts
 create mode 100644 apps/desktop/src/utils/network-health.ts
 create mode 100644 apps/web/app/api/desktop/[...route]/health.ts

diff --git a/apps/desktop/src/components/NetworkHealthIndicator.tsx b/apps/desktop/src/components/NetworkHealthIndicator.tsx
new file mode 100644
index 00000000000..d951935dc13
--- /dev/null
+++ b/apps/desktop/src/components/NetworkHealthIndicator.tsx
@@ -0,0 +1,133 @@
+import { cx } from "cva";
+import { Show } from "solid-js";
+import Tooltip from "~/components/Tooltip";
+import {
+	isRecordingInProgress,
+	networkHealth,
+	runSpeedTest,
+	runUploadHealthCheck,
+	speedTest,
+} from "~/utils/network-health";
+import IconLucideAlertTriangle from "~icons/lucide/alert-triangle";
+import IconLucideRefreshCw from "~icons/lucide/refresh-cw";
+import IconLucideWifi from "~icons/lucide/wifi";
+
+interface NetworkHealthIndicatorProps {
+	class?: string;
+}
+
+export default function NetworkHealthIndicator(
+	props: NetworkHealthIndicatorProps,
+) {
+	const isUnhealthy = () => networkHealth().status === "unhealthy";
+	const isChecking = () =>
+		networkHealth().status === "checking" || speedTest().status === "running";
+	const isRecording = () => isRecordingInProgress();
+
+	const handleRefresh = async (e: MouseEvent) => {
+		e.stopPropagation();
+		if (isRecording() || isChecking()) return;
+		await runUploadHealthCheck();
+		await runSpeedTest();
+	};
+
+	const speedLabel = () => {
+		const mbps = speedTest().speedMbps;
+		if (mbps === null) return "Checking...";
+		return `${mbps} Mbps`;
+	};
+
+	const qualityLabel = () => {
+		const tier = speedTest().qualityTier;
+		const res = speedTest().recommendedResolution;
+		if (!tier) return "Standard (1080p)";
+		if (tier === "high") return `Full (${res}p)`;
+		if (tier === "medium") return `Standard (${res}p)`;
+		return `Adapted (${res}p)`;
+	};
+
+	const dotColor = () => {
+		if (isUnhealthy()) return "bg-red-9";
+		if (speedTest().status === "running") return "bg-blue-9 animate-pulse";
+		const speed = speedTest().speedMbps;
+		if (speed === null) return "bg-gray-8";
+		if (speed >= 15) return "bg-green-9";
+		if (speed >= 5) return "bg-blue-9";
+		return "bg-amber-9";
+	};
+
+	const tooltipContent = () => (
+		<div class="flex flex-col gap-1 p-1 text-left text-xs min-w-44">
+			<div class="flex items-center justify-between font-semibold">
+				<span>Network Health</span>
+				<span
+					class={cx(
+						"text-[10px] uppercase font-bold",
+						isUnhealthy() ? "text-red-10" : "text-green-10",
+					)}
+				>
+					{isUnhealthy() ? "Failed" : "Operational"}
+				</span>
+			</div>
+			<div class="flex items-center justify-between text-gray-11">
+				<span>Upload Speed:</span>
+				<span class="font-medium text-gray-12">{speedLabel()}</span>
+			</div>
+			<div class="flex items-center justify-between text-gray-11">
+				<span>Recording Quality:</span>
+				<span class="font-medium text-gray-12">{qualityLabel()}</span>
+			</div>
+			<Show when={isUnhealthy()}>
+				<div class="mt-1 rounded bg-red-3 p-1.5 text-[11px] text-red-11 border border-red-6">
+					Upload test failed. Recording uploads might fail. Please contact
+					support at hello@cap.so
+				</div>
+			</Show>
+			<div class="mt-1 pt-1 border-t border-gray-6 flex justify-end">
+				<button
+					type="button"
+					onClick={handleRefresh}
+					disabled={isRecording() || isChecking()}
+					class="flex items-center gap-1 text-[11px] text-gray-11 hover:text-gray-12 disabled:opacity-50"
+				>
+					<IconLucideRefreshCw
+						class={cx("size-3", isChecking() && "animate-spin")}
+					/>
+					<span>Retest Speed</span>
+				</button>
+			</div>
+		</div>
+	);
+
+	return (
+		<div
+			class={cx("inline-flex items-center gap-1.5 select-none", props.class)}
+		>
+			<Tooltip content={tooltipContent()}>
+				<button
+					type="button"
+					onClick={handleRefresh}
+					disabled={isRecording()}
+					aria-label="Network health and speed indicator"
+					class={cx(
+						"flex items-center gap-1.5 px-2 py-0.5 rounded-full text-[11px] transition-colors border",
+						isUnhealthy()
+							? "bg-red-3 text-red-11 border-red-6 hover:bg-red-4"
+							: "bg-gray-2 text-gray-11 border-gray-6 hover:bg-gray-3 hover:text-gray-12",
+					)}
+				>
+					<Show
+						when={!isUnhealthy()}
+						fallback={<IconLucideAlertTriangle class="size-3 text-red-9" />}
+					>
+						<span class={cx("size-1.5 rounded-full shrink-0", dotColor())} />
+						<IconLucideWifi class="size-3 shrink-0" />
+					</Show>
+					<span class="font-medium truncate max-w-20">
+						{isUnhealthy() ? "Upload Error" : speedLabel()}
+					</span>
+				</button>
+			</Tooltip>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx b/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
index b0981c60573..178feadad43 100644
--- a/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
+++ b/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
@@ -37,6 +37,7 @@ import { createStore, produce, reconcile } from "solid-js/store";
 import toast from "solid-toast";
 import { Transition } from "solid-transition-group";
 import Mode from "~/components/Mode";
+import NetworkHealthIndicator from "~/components/NetworkHealthIndicator";
 import { RecoveryToast } from "~/components/RecoveryToast";
 import Tooltip from "~/components/Tooltip";
 import { Input } from "~/routes/editor/ui";
@@ -59,6 +60,10 @@ import {
 	importVideoFromPicker,
 	showImportError,
 } from "~/utils/importMedia";
+import {
+	initNetworkHealthMonitoring,
+	setRecordingState,
+} from "~/utils/network-health";
 import {
 	createCameraMutation,
 	createCleanCaptureQuery,
@@ -1846,6 +1851,16 @@ function Page() {
 	const isRecording = () => !!currentRecording.data;
 	const isActivelyRecording = () =>
 		currentRecording.data?.status === "recording";
+
+	createEffect(() => {
+		setRecordingState(isRecording());
+	});
+
+	onMount(() => {
+		const cleanup = initNetworkHealthMonitoring();
+		onCleanup(cleanup);
+	});
+
 	const auth = authStore.createQuery();
 	const recordingSettingsQuery = recordingDeviceSettingsStore.createQuery();
 	const generalSettings = generalSettingsStore.createQuery();
@@ -2984,6 +2999,9 @@ function Page() {
 					</div>
 				</div>
 				<BaseControls />
+				<div class="flex items-center justify-end pt-1 px-0.5 text-xs text-gray-11">
+					<NetworkHealthIndicator />
+				</div>
 			</div>
 		</Transition>
 	);
@@ -3153,6 +3171,7 @@ function Page() {
 											? new URL("/dashboard", serverUrl()).toString()
 											: serverUrl()
 									}
+									rel="noopener"
 								>
 									<IconCapLogoFullDark class="hidden dark:block" />
 									<IconCapLogoFull class="block dark:hidden" />
diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
new file mode 100644
index 00000000000..adf15987e66
--- /dev/null
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	calculateSpeedMbps,
+	determineQualityTierAndResolution,
+	isRecordingInProgress,
+	networkHealth,
+	runSpeedTest,
+	runUploadHealthCheck,
+	setRecordingState,
+	speedTest,
+} from "./network-health";
+
+describe("network-health speed test & quality adaptation", () => {
+	it("correctly maps speeds to adaptive quality tiers and resolutions", () => {
+		const highTier = determineQualityTierAndResolution(25);
+		expect(highTier.qualityTier).toBe("high");
+		expect(highTier.recommendedResolution).toBe(2160);
+
+		const mediumTier = determineQualityTierAndResolution(10);
+		expect(mediumTier.qualityTier).toBe("medium");
+		expect(mediumTier.recommendedResolution).toBe(1920);
+
+		const lowTier = determineQualityTierAndResolution(3.5);
+		expect(lowTier.qualityTier).toBe("low");
+		expect(lowTier.recommendedResolution).toBe(1280);
+
+		const minTier = determineQualityTierAndResolution(1.2);
+		expect(minTier.qualityTier).toBe("low");
+		expect(minTier.recommendedResolution).toBe(960);
+	});
+
+	it("calculates upload speed in Mbps accurately", () => {
+		const oneMegabyte = 1024 * 1024;
+		const durationMs = 1000;
+		const speed = calculateSpeedMbps(oneMegabyte, durationMs);
+		expect(speed).toBeCloseTo(8.4, 0);
+
+		expect(calculateSpeedMbps(0, 1000)).toBe(0);
+		expect(calculateSpeedMbps(1024, 0)).toBe(0);
+	});
+
+	it("does not perform speed checks once recording has already started", async () => {
+		setRecordingState(true);
+		expect(isRecordingInProgress()).toBe(true);
+
+		const result = await runSpeedTest();
+		expect(result).toBe(speedTest().speedMbps);
+
+		setRecordingState(false);
+		expect(isRecordingInProgress()).toBe(false);
+	});
+
+	it("manages health check state transitions", async () => {
+		const originalFetch = globalThis.fetch;
+		globalThis.fetch = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ({ status: "ok", healthy: true }),
+		} as Response);
+
+		const success = await runUploadHealthCheck();
+		expect(success).toBe(true);
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
+		globalThis.fetch = vi
+			.fn()
+			.mockRejectedValue(new Error("Connection refused"));
+		const failure = await runUploadHealthCheck();
+		expect(failure).toBe(false);
+		expect(networkHealth().status).toBe("unhealthy");
+		expect(networkHealth().error).toContain("Connection refused");
+
+		globalThis.fetch = originalFetch;
+	});
+});
diff --git a/apps/desktop/src/utils/network-health.ts b/apps/desktop/src/utils/network-health.ts
new file mode 100644
index 00000000000..9265c46f6ed
--- /dev/null
+++ b/apps/desktop/src/utils/network-health.ts
@@ -0,0 +1,306 @@
+export type QualityTier = "high" | "medium" | "low";
+
+export interface NetworkHealthState {
+	status: "idle" | "checking" | "healthy" | "unhealthy";
+	lastChecked: number | null;
+	error: string | null;
+}
+
+export interface SpeedTestState {
+	status: "idle" | "running" | "completed" | "error";
+	speedMbps: number | null;
+	qualityTier: QualityTier | null;
+	recommendedResolution: number;
+	lastTested: number | null;
+	error: string | null;
+}
+
+export const SPEED_THRESHOLDS = {
+	highSpeedMinMbps: 15,
+	mediumSpeedMinMbps: 5,
+	lowSpeedMinMbps: 2,
+} as const;
+
+export const RESOLUTION_PRESETS = {
+	high: 2160,
+	medium: 1920,
+	low: 1280,
+	minimum: 960,
+} as const;
+
+type SignalGetter<T> = () => T;
+type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;
+
+function createFallbackSignal<T>(
+	initial: T,
+): [SignalGetter<T>, SignalSetter<T>] {
+	let current = initial;
+	return [
+		() => current,
+		(update: T | ((prev: T) => T)) => {
+			current =
+				typeof update === "function"
+					? (update as (prev: T) => T)(current)
+					: update;
+		},
+	];
+}
+
+let signalFactory: <T>(initial: T) => [SignalGetter<T>, SignalSetter<T>] =
+	createFallbackSignal;
+
+try {
+	const solid = await import("solid-js");
+	if (solid && typeof solid.createSignal === "function") {
+		signalFactory = solid.createSignal;
+	}
+} catch {
+	// Fallback to standalone reactive signal
+}
+
+async function getServerUrl(): Promise<string> {
+	try {
+		const { getConfiguredServerUrl } = await import("./web-api");
+		return await getConfiguredServerUrl();
+	} catch {
+		return "http://localhost:3000";
+	}
+}
+
+const [networkHealth, setNetworkHealth] = signalFactory<NetworkHealthState>({
+	status: "idle",
+	lastChecked: null,
+	error: null,
+});
+
+const [speedTest, setSpeedTest] = signalFactory<SpeedTestState>({
+	status: "idle",
+	speedMbps: null,
+	qualityTier: null,
+	recommendedResolution: RESOLUTION_PRESETS.medium,
+	lastTested: null,
+	error: null,
+});
+
+let isRecordingActive = false;
+let activeSpeedTestAbort: AbortController | null = null;
+
+export function setRecordingState(active: boolean) {
+	isRecordingActive = active;
+	if (active && activeSpeedTestAbort) {
+		activeSpeedTestAbort.abort();
+		activeSpeedTestAbort = null;
+		setSpeedTest((prev) => ({
+			...prev,
+			status: prev.speedMbps !== null ? "completed" : "idle",
+		}));
+	}
+}
+
+export function isRecordingInProgress(): boolean {
+	return isRecordingActive;
+}
+
+export function determineQualityTierAndResolution(speedMbps: number): {
+	qualityTier: QualityTier;
+	recommendedResolution: number;
+} {
+	if (speedMbps >= SPEED_THRESHOLDS.highSpeedMinMbps) {
+		return {
+			qualityTier: "high",
+			recommendedResolution: RESOLUTION_PRESETS.high,
+		};
+	}
+	if (speedMbps >= SPEED_THRESHOLDS.mediumSpeedMinMbps) {
+		return {
+			qualityTier: "medium",
+			recommendedResolution: RESOLUTION_PRESETS.medium,
+		};
+	}
+	if (speedMbps >= SPEED_THRESHOLDS.lowSpeedMinMbps) {
+		return {
+			qualityTier: "low",
+			recommendedResolution: RESOLUTION_PRESETS.low,
+		};
+	}
+	return {
+		qualityTier: "low",
+		recommendedResolution: RESOLUTION_PRESETS.minimum,
+	};
+}
+
+export function calculateSpeedMbps(bytes: number, durationMs: number): number {
+	if (durationMs <= 0 || bytes <= 0) return 0;
+	const durationSeconds = durationMs / 1000;
+	const bits = bytes * 8;
+	const mbps = bits / (durationSeconds * 1_000_000);
+	return Math.round(mbps * 10) / 10;
+}
+
+export async function runUploadHealthCheck(): Promise<boolean> {
+	setNetworkHealth((prev) => ({
+		...prev,
+		status: "checking",
+		error: null,
+	}));
+
+	try {
+		const baseUrl = await getServerUrl();
+		const targetUrl = new URL("/api/desktop/health", baseUrl).toString();
+
+		const testPayload = JSON.stringify({
+			type: "screen_recording_health_check",
+			timestamp: Date.now(),
+			payload: "cap_health_check_ping_data_12345",
+		});
+
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 8000);
+
+		const response = await fetch(targetUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: testPayload,
+			signal: controller.signal,
+		});
+
+		clearTimeout(timeoutId);
+
+		if (!response.ok) {
+			throw new Error(`Health check returned HTTP ${response.status}`);
+		}
+
+		const data = (await response.json()) as {
+			healthy?: boolean;
+			status?: string;
+		};
+		const isHealthy = data.healthy === true || data.status === "ok";
+
+		if (!isHealthy) {
+			throw new Error("Server responded with unhealthy status");
+		}
+
+		setNetworkHealth({
+			status: "healthy",
+			lastChecked: Date.now(),
+			error: null,
+		});
+		return true;
+	} catch (error) {
+		const errorMessage =
+			error instanceof Error ? error.message : "Upload health check failed";
+		setNetworkHealth({
+			status: "unhealthy",
+			lastChecked: Date.now(),
+			error: errorMessage,
+		});
+		return false;
+	}
+}
+
+export async function runSpeedTest(): Promise<number | null> {
+	if (isRecordingActive) {
+		return speedTest().speedMbps;
+	}
+
+	activeSpeedTestAbort?.abort();
+	const controller = new AbortController();
+	activeSpeedTestAbort = controller;
+
+	setSpeedTest((prev) => ({
+		...prev,
+		status: "running",
+		error: null,
+	}));
+
+	try {
+		const baseUrl = await getServerUrl();
+		const targetUrl = new URL(
+			"/api/desktop/health/speed-test",
+			baseUrl,
+		).toString();
+
+		const chunkSize = 256 * 1024;
+		const buffer = new Uint8Array(chunkSize);
+		for (let i = 0; i < chunkSize; i += 64) {
+			buffer[i] = i & 0xff;
+		}
+
+		const startTime = performance.now();
+		const response = await fetch(targetUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/octet-stream",
+			},
+			body: buffer,
+			signal: controller.signal,
+		});
+
+		const durationMs = performance.now() - startTime;
+
+		if (isRecordingActive) {
+			return speedTest().speedMbps;
+		}
+
+		if (!response.ok) {
+			throw new Error(`Speed test returned HTTP ${response.status}`);
+		}
+
+		const calculatedSpeed = calculateSpeedMbps(chunkSize, durationMs);
+		const { qualityTier, recommendedResolution } =
+			determineQualityTierAndResolution(calculatedSpeed);
+
+		setSpeedTest({
+			status: "completed",
+			speedMbps: calculatedSpeed,
+			qualityTier,
+			recommendedResolution,
+			lastTested: Date.now(),
+			error: null,
+		});
+
+		try {
+			const { generalSettingsStore } = await import("~/store");
+			await generalSettingsStore.set({
+				instantModeMaxResolution: recommendedResolution,
+			});
+		} catch {}
+
+		activeSpeedTestAbort = null;
+		return calculatedSpeed;
+	} catch (error) {
+		if (controller.signal.aborted) {
+			return speedTest().speedMbps;
+		}
+
+		const errorMessage =
+			error instanceof Error ? error.message : "Speed test failed";
+		setSpeedTest((prev) => ({
+			...prev,
+			status: "error",
+			error: errorMessage,
+		}));
+		activeSpeedTestAbort = null;
+		return null;
+	}
+}
+
+export function initNetworkHealthMonitoring(): () => void {
+	void runUploadHealthCheck();
+	void runSpeedTest();
+
+	const interval = setInterval(() => {
+		if (!isRecordingActive) {
+			void runSpeedTest();
+		}
+	}, 45_000);
+
+	return () => {
+		clearInterval(interval);
+		activeSpeedTestAbort?.abort();
+	};
+}
+
+export { networkHealth, speedTest };
diff --git a/apps/web/app/api/desktop/[...route]/health.ts b/apps/web/app/api/desktop/[...route]/health.ts
new file mode 100644
index 00000000000..72bb30e4747
--- /dev/null
+++ b/apps/web/app/api/desktop/[...route]/health.ts
@@ -0,0 +1,66 @@
+import { Hono } from "hono";
+import { withOptionalAuth } from "../../utils";
+
+export const app = new Hono().use(withOptionalAuth);
+
+app.get("/", (c) => {
+	return c.json({
+		status: "ok",
+		service: "cap-desktop-health",
+		timestamp: Date.now(),
+	});
+});
+
+app.post("/", async (c) => {
+	try {
+		const contentType = c.req.header("content-type") || "";
+		let bytesReceived = 0;
+
+		if (contentType.includes("application/json")) {
+			const json = await c.req.json().catch(() => ({}));
+			const payload = typeof json.payload === "string" ? json.payload : "";
+			bytesReceived = Buffer.byteLength(payload, "utf8");
+		} else {
+			const bodyBuffer = await c.req
+				.arrayBuffer()
+				.catch(() => new ArrayBuffer(0));
+			bytesReceived = bodyBuffer.byteLength;
+		}
+
+		return c.json({
+			status: "ok",
+			healthy: true,
+			bytesReceived,
+			timestamp: Date.now(),
+		});
+	} catch (error) {
+		return c.json(
+			{
+				status: "error",
+				healthy: false,
+				error: error instanceof Error ? error.message : "Health check failed",
+				timestamp: Date.now(),
+			},
+			500,
+		);
+	}
+});
+
+app.post("/speed-test", async (c) => {
+	try {
+		const body = await c.req.arrayBuffer().catch(() => new ArrayBuffer(0));
+		return c.json({
+			status: "ok",
+			bytesReceived: body.byteLength,
+			timestamp: Date.now(),
+		});
+	} catch (error) {
+		return c.json(
+			{
+				status: "error",
+				error: error instanceof Error ? error.message : "Speed test failed",
+			},
+			500,
+		);
+	}
+});
diff --git a/apps/web/app/api/desktop/[...route]/route.ts b/apps/web/app/api/desktop/[...route]/route.ts
index 36857200042..de142cd86c4 100644
--- a/apps/web/app/api/desktop/[...route]/route.ts
+++ b/apps/web/app/api/desktop/[...route]/route.ts
@@ -3,6 +3,7 @@ import { handle } from "hono/vercel";
 
 import { corsMiddleware } from "../../utils";
 
+import * as health from "./health";
 import * as root from "./root";
 import * as s3Config from "./s3Config";
 import * as session from "./session";
@@ -12,6 +13,7 @@ import * as video from "./video";
 const app = new Hono()
 	.basePath("/api/desktop")
 	.use(corsMiddleware)
+	.route("/health", health.app)
 	.route("/s3/config", s3Config.app)
 	.route("/session", session.app)
 	.route("/storage", storage.app)

From 58fccf2a43dedf3dc9e6b28fd487f804ed225dc6 Mon Sep 17 00:00:00 2001
From: gilnett <gilles.deschuyteneer@gmail.com>
Date: Thu, 8 Oct 2026 18:55:11 +0200
Subject: [PATCH 2/6] fix(desktop): address review feedback on effect api,
 tauri http, and reactive indicators

---
 ...cator.tsx => network-health-indicator.tsx} |  49 +++--
 .../routes/(window-chrome)/new-main/index.tsx |   2 +-
 apps/desktop/src/utils/network-health.test.ts |  43 +++--
 apps/desktop/src/utils/network-health.ts      | 177 ++++++++++--------
 apps/web/app/api/desktop/[...route]/health.ts |  66 -------
 apps/web/app/api/desktop/[...route]/route.ts  |   2 -
 apps/web/app/api/desktop/health/route.ts      |  67 +++++++
 7 files changed, 226 insertions(+), 180 deletions(-)
 rename apps/desktop/src/components/{NetworkHealthIndicator.tsx => network-health-indicator.tsx} (73%)
 delete mode 100644 apps/web/app/api/desktop/[...route]/health.ts
 create mode 100644 apps/web/app/api/desktop/health/route.ts

diff --git a/apps/desktop/src/components/NetworkHealthIndicator.tsx b/apps/desktop/src/components/network-health-indicator.tsx
similarity index 73%
rename from apps/desktop/src/components/NetworkHealthIndicator.tsx
rename to apps/desktop/src/components/network-health-indicator.tsx
index d951935dc13..b0450f2a4ba 100644
--- a/apps/desktop/src/components/NetworkHealthIndicator.tsx
+++ b/apps/desktop/src/components/network-health-indicator.tsx
@@ -22,7 +22,7 @@ export default function NetworkHealthIndicator(
 	const isUnhealthy = () => networkHealth().status === "unhealthy";
 	const isChecking = () =>
 		networkHealth().status === "checking" || speedTest().status === "running";
-	const isRecording = () => isRecordingInProgress();
+	const isRecording = isRecordingInProgress;
 
 	const handleRefresh = async (e: MouseEvent) => {
 		e.stopPropagation();
@@ -32,23 +32,25 @@ export default function NetworkHealthIndicator(
 	};
 
 	const speedLabel = () => {
-		const mbps = speedTest().speedMbps;
-		if (mbps === null) return "Checking...";
-		return `${mbps} Mbps`;
+		if (speedTest().status === "running") return "Testing...";
+		if (speedTest().status === "error" && speedTest().speedMbps === null)
+			return "Failed";
+		if (speedTest().speedMbps !== null) return `${speedTest().speedMbps} Mbps`;
+		if (networkHealth().status === "checking") return "Checking...";
+		if (isUnhealthy()) return "Offline";
+		return "Ready";
 	};
 
 	const qualityLabel = () => {
-		const tier = speedTest().qualityTier;
-		const res = speedTest().recommendedResolution;
-		if (!tier) return "Standard (1080p)";
-		if (tier === "high") return `Full (${res}p)`;
-		if (tier === "medium") return `Standard (${res}p)`;
-		return `Adapted (${res}p)`;
+		const label = speedTest().recommendedLabel;
+		return label ? `${label}` : "1080p";
 	};
 
 	const dotColor = () => {
 		if (isUnhealthy()) return "bg-red-9";
 		if (speedTest().status === "running") return "bg-blue-9 animate-pulse";
+		if (speedTest().status === "error" && speedTest().speedMbps === null)
+			return "bg-red-9";
 		const speed = speedTest().speedMbps;
 		if (speed === null) return "bg-gray-8";
 		if (speed >= 15) return "bg-green-9";
@@ -63,10 +65,15 @@ export default function NetworkHealthIndicator(
 				<span
 					class={cx(
 						"text-[10px] uppercase font-bold",
-						isUnhealthy() ? "text-red-10" : "text-green-10",
+						isUnhealthy() || speedTest().status === "error"
+							? "text-red-10"
+							: "text-green-10",
 					)}
 				>
-					{isUnhealthy() ? "Failed" : "Operational"}
+					{isUnhealthy() ||
+					(speedTest().status === "error" && speedTest().speedMbps === null)
+						? "Error"
+						: "Operational"}
 				</span>
 			</div>
 			<div class="flex items-center justify-between text-gray-11">
@@ -74,13 +81,12 @@ export default function NetworkHealthIndicator(
 				<span class="font-medium text-gray-12">{speedLabel()}</span>
 			</div>
 			<div class="flex items-center justify-between text-gray-11">
-				<span>Recording Quality:</span>
+				<span>Recommended Quality:</span>
 				<span class="font-medium text-gray-12">{qualityLabel()}</span>
 			</div>
-			<Show when={isUnhealthy()}>
+			<Show when={networkHealth().error || speedTest().error}>
 				<div class="mt-1 rounded bg-red-3 p-1.5 text-[11px] text-red-11 border border-red-6">
-					Upload test failed. Recording uploads might fail. Please contact
-					support at hello@cap.so
+					{networkHealth().error ?? speedTest().error}
 				</div>
 			</Show>
 			<div class="mt-1 pt-1 border-t border-gray-6 flex justify-end">
@@ -111,13 +117,19 @@ export default function NetworkHealthIndicator(
 					aria-label="Network health and speed indicator"
 					class={cx(
 						"flex items-center gap-1.5 px-2 py-0.5 rounded-full text-[11px] transition-colors border",
-						isUnhealthy()
+						isUnhealthy() ||
+							(speedTest().status === "error" && speedTest().speedMbps === null)
 							? "bg-red-3 text-red-11 border-red-6 hover:bg-red-4"
 							: "bg-gray-2 text-gray-11 border-gray-6 hover:bg-gray-3 hover:text-gray-12",
 					)}
 				>
 					<Show
-						when={!isUnhealthy()}
+						when={
+							!isUnhealthy() &&
+							!(
+								speedTest().status === "error" && speedTest().speedMbps === null
+							)
+						}
 						fallback={<IconLucideAlertTriangle class="size-3 text-red-9" />}
 					>
 						<span class={cx("size-1.5 rounded-full shrink-0", dotColor())} />
@@ -131,3 +143,4 @@ export default function NetworkHealthIndicator(
 		</div>
 	);
 }
+export { NetworkHealthIndicator };
diff --git a/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx b/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
index 178feadad43..a72db044b92 100644
--- a/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
+++ b/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
@@ -37,7 +37,7 @@ import { createStore, produce, reconcile } from "solid-js/store";
 import toast from "solid-toast";
 import { Transition } from "solid-transition-group";
 import Mode from "~/components/Mode";
-import NetworkHealthIndicator from "~/components/NetworkHealthIndicator";
+import NetworkHealthIndicator from "~/components/network-health-indicator";
 import { RecoveryToast } from "~/components/RecoveryToast";
 import Tooltip from "~/components/Tooltip";
 import { Input } from "~/routes/editor/ui";
diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
index adf15987e66..e4d1923ddcc 100644
--- a/apps/desktop/src/utils/network-health.test.ts
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 import {
 	calculateSpeedMbps,
 	determineQualityTierAndResolution,
+	formatResolutionLabel,
 	isRecordingInProgress,
 	networkHealth,
 	runSpeedTest,
@@ -11,22 +12,31 @@ import {
 } from "./network-health";
 
 describe("network-health speed test & quality adaptation", () => {
-	it("correctly maps speeds to adaptive quality tiers and resolutions", () => {
-		const highTier = determineQualityTierAndResolution(25);
+	it("correctly maps speeds to adaptive quality tiers and resolution labels", () => {
+		const ultraTier = determineQualityTierAndResolution(30);
+		expect(ultraTier.qualityTier).toBe("high");
+		expect(ultraTier.recommendedResolution).toBe(3840);
+		expect(ultraTier.recommendedLabel).toBe("4K");
+
+		const highTier = determineQualityTierAndResolution(18);
 		expect(highTier.qualityTier).toBe("high");
-		expect(highTier.recommendedResolution).toBe(2160);
+		expect(highTier.recommendedResolution).toBe(1920);
+		expect(highTier.recommendedLabel).toBe("1080p");
 
-		const mediumTier = determineQualityTierAndResolution(10);
+		const mediumTier = determineQualityTierAndResolution(8);
 		expect(mediumTier.qualityTier).toBe("medium");
-		expect(mediumTier.recommendedResolution).toBe(1920);
+		expect(mediumTier.recommendedResolution).toBe(1280);
+		expect(mediumTier.recommendedLabel).toBe("720p");
 
-		const lowTier = determineQualityTierAndResolution(3.5);
+		const lowTier = determineQualityTierAndResolution(1.5);
 		expect(lowTier.qualityTier).toBe("low");
-		expect(lowTier.recommendedResolution).toBe(1280);
+		expect(lowTier.recommendedResolution).toBe(960);
+		expect(lowTier.recommendedLabel).toBe("540p");
 
-		const minTier = determineQualityTierAndResolution(1.2);
-		expect(minTier.qualityTier).toBe("low");
-		expect(minTier.recommendedResolution).toBe(960);
+		expect(formatResolutionLabel(3840)).toBe("4K");
+		expect(formatResolutionLabel(1920)).toBe("1080p");
+		expect(formatResolutionLabel(1280)).toBe("720p");
+		expect(formatResolutionLabel(960)).toBe("540p");
 	});
 
 	it("calculates upload speed in Mbps accurately", () => {
@@ -50,11 +60,11 @@ describe("network-health speed test & quality adaptation", () => {
 		expect(isRecordingInProgress()).toBe(false);
 	});
 
-	it("manages health check state transitions", async () => {
+	it("manages health check state transitions and clears errors upon recovery", async () => {
 		const originalFetch = globalThis.fetch;
 		globalThis.fetch = vi.fn().mockResolvedValue({
 			ok: true,
-			json: async () => ({ status: "ok", healthy: true }),
+			json: async () => ({ status: "ok" }),
 		} as Response);
 
 		const success = await runUploadHealthCheck();
@@ -70,6 +80,15 @@ describe("network-health speed test & quality adaptation", () => {
 		expect(networkHealth().status).toBe("unhealthy");
 		expect(networkHealth().error).toContain("Connection refused");
 
+		globalThis.fetch = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ({ status: "ok" }),
+		} as Response);
+		const recovery = await runUploadHealthCheck();
+		expect(recovery).toBe(true);
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
 		globalThis.fetch = originalFetch;
 	});
 });
diff --git a/apps/desktop/src/utils/network-health.ts b/apps/desktop/src/utils/network-health.ts
index 9265c46f6ed..8d713d916fc 100644
--- a/apps/desktop/src/utils/network-health.ts
+++ b/apps/desktop/src/utils/network-health.ts
@@ -1,3 +1,6 @@
+import { fetch as tauriFetch } from "@tauri-apps/plugin-http";
+import { createSignal } from "solid-js";
+
 export type QualityTier = "high" | "medium" | "low";
 
 export interface NetworkHealthState {
@@ -11,6 +14,7 @@ export interface SpeedTestState {
 	speedMbps: number | null;
 	qualityTier: QualityTier | null;
 	recommendedResolution: number;
+	recommendedLabel: string;
 	lastTested: number | null;
 	error: string | null;
 }
@@ -22,40 +26,25 @@ export const SPEED_THRESHOLDS = {
 } as const;
 
 export const RESOLUTION_PRESETS = {
-	high: 2160,
-	medium: 1920,
-	low: 1280,
-	minimum: 960,
+	ultra: 3840,
+	high: 1920,
+	medium: 1280,
+	low: 960,
 } as const;
 
-type SignalGetter<T> = () => T;
-type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;
-
-function createFallbackSignal<T>(
-	initial: T,
-): [SignalGetter<T>, SignalSetter<T>] {
-	let current = initial;
-	return [
-		() => current,
-		(update: T | ((prev: T) => T)) => {
-			current =
-				typeof update === "function"
-					? (update as (prev: T) => T)(current)
-					: update;
-		},
-	];
+export function formatResolutionLabel(width: number): string {
+	if (width >= 3840) return "4K";
+	if (width >= 2560) return "1440p";
+	if (width >= 1920) return "1080p";
+	if (width >= 1280) return "720p";
+	return "540p";
 }
 
-let signalFactory: <T>(initial: T) => [SignalGetter<T>, SignalSetter<T>] =
-	createFallbackSignal;
-
-try {
-	const solid = await import("solid-js");
-	if (solid && typeof solid.createSignal === "function") {
-		signalFactory = solid.createSignal;
+function getHttpFetch(): typeof globalThis.fetch {
+	if (typeof window !== "undefined") {
+		return tauriFetch;
 	}
-} catch {
-	// Fallback to standalone reactive signal
+	return globalThis.fetch;
 }
 
 async function getServerUrl(): Promise<string> {
@@ -67,26 +56,27 @@ async function getServerUrl(): Promise<string> {
 	}
 }
 
-const [networkHealth, setNetworkHealth] = signalFactory<NetworkHealthState>({
+const [networkHealth, setNetworkHealth] = createSignal<NetworkHealthState>({
 	status: "idle",
 	lastChecked: null,
 	error: null,
 });
 
-const [speedTest, setSpeedTest] = signalFactory<SpeedTestState>({
+const [speedTest, setSpeedTest] = createSignal<SpeedTestState>({
 	status: "idle",
 	speedMbps: null,
 	qualityTier: null,
-	recommendedResolution: RESOLUTION_PRESETS.medium,
+	recommendedResolution: RESOLUTION_PRESETS.high,
+	recommendedLabel: "1080p",
 	lastTested: null,
 	error: null,
 });
 
-let isRecordingActive = false;
+const [isRecordingSignal, setIsRecordingSignal] = createSignal(false);
 let activeSpeedTestAbort: AbortController | null = null;
 
 export function setRecordingState(active: boolean) {
-	isRecordingActive = active;
+	setIsRecordingSignal(active);
 	if (active && activeSpeedTestAbort) {
 		activeSpeedTestAbort.abort();
 		activeSpeedTestAbort = null;
@@ -98,34 +88,39 @@ export function setRecordingState(active: boolean) {
 }
 
 export function isRecordingInProgress(): boolean {
-	return isRecordingActive;
+	return isRecordingSignal();
 }
 
 export function determineQualityTierAndResolution(speedMbps: number): {
 	qualityTier: QualityTier;
 	recommendedResolution: number;
+	recommendedLabel: string;
 } {
+	if (speedMbps >= 25) {
+		return {
+			qualityTier: "high",
+			recommendedResolution: RESOLUTION_PRESETS.ultra,
+			recommendedLabel: "4K",
+		};
+	}
 	if (speedMbps >= SPEED_THRESHOLDS.highSpeedMinMbps) {
 		return {
 			qualityTier: "high",
 			recommendedResolution: RESOLUTION_PRESETS.high,
+			recommendedLabel: "1080p",
 		};
 	}
 	if (speedMbps >= SPEED_THRESHOLDS.mediumSpeedMinMbps) {
 		return {
 			qualityTier: "medium",
 			recommendedResolution: RESOLUTION_PRESETS.medium,
-		};
-	}
-	if (speedMbps >= SPEED_THRESHOLDS.lowSpeedMinMbps) {
-		return {
-			qualityTier: "low",
-			recommendedResolution: RESOLUTION_PRESETS.low,
+			recommendedLabel: "720p",
 		};
 	}
 	return {
 		qualityTier: "low",
-		recommendedResolution: RESOLUTION_PRESETS.minimum,
+		recommendedResolution: RESOLUTION_PRESETS.low,
+		recommendedLabel: "540p",
 	};
 }
 
@@ -148,21 +143,12 @@ export async function runUploadHealthCheck(): Promise<boolean> {
 		const baseUrl = await getServerUrl();
 		const targetUrl = new URL("/api/desktop/health", baseUrl).toString();
 
-		const testPayload = JSON.stringify({
-			type: "screen_recording_health_check",
-			timestamp: Date.now(),
-			payload: "cap_health_check_ping_data_12345",
-		});
-
 		const controller = new AbortController();
 		const timeoutId = setTimeout(() => controller.abort(), 8000);
 
-		const response = await fetch(targetUrl, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-			},
-			body: testPayload,
+		const fetchFn = getHttpFetch();
+		const response = await fetchFn(targetUrl, {
+			method: "GET",
 			signal: controller.signal,
 		});
 
@@ -173,10 +159,9 @@ export async function runUploadHealthCheck(): Promise<boolean> {
 		}
 
 		const data = (await response.json()) as {
-			healthy?: boolean;
 			status?: string;
 		};
-		const isHealthy = data.healthy === true || data.status === "ok";
+		const isHealthy = data.status === "ok";
 
 		if (!isHealthy) {
 			throw new Error("Server responded with unhealthy status");
@@ -201,7 +186,7 @@ export async function runUploadHealthCheck(): Promise<boolean> {
 }
 
 export async function runSpeedTest(): Promise<number | null> {
-	if (isRecordingActive) {
+	if (isRecordingSignal()) {
 		return speedTest().speedMbps;
 	}
 
@@ -217,30 +202,48 @@ export async function runSpeedTest(): Promise<number | null> {
 
 	try {
 		const baseUrl = await getServerUrl();
-		const targetUrl = new URL(
-			"/api/desktop/health/speed-test",
-			baseUrl,
-		).toString();
-
-		const chunkSize = 256 * 1024;
-		const buffer = new Uint8Array(chunkSize);
-		for (let i = 0; i < chunkSize; i += 64) {
-			buffer[i] = i & 0xff;
+		const targetUrl = new URL("/api/desktop/health", baseUrl).toString();
+		const fetchFn = getHttpFetch();
+
+		const warmupPayload = JSON.stringify({
+			payload: "x".repeat(32 * 1024),
+		});
+
+		const warmupResponse = await fetchFn(targetUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: warmupPayload,
+			signal: controller.signal,
+		});
+
+		if (!warmupResponse.ok) {
+			throw new Error(`Warmup failed with HTTP ${warmupResponse.status}`);
 		}
 
+		if (isRecordingSignal()) {
+			return speedTest().speedMbps;
+		}
+
+		const sampleBytes = 512 * 1024;
+		const sampleData = "a".repeat(sampleBytes);
+		const testPayload = JSON.stringify({
+			payload: sampleData,
+		});
+
 		const startTime = performance.now();
-		const response = await fetch(targetUrl, {
+		const response = await fetchFn(targetUrl, {
 			method: "POST",
 			headers: {
-				"Content-Type": "application/octet-stream",
+				"Content-Type": "application/json",
 			},
-			body: buffer,
+			body: testPayload,
 			signal: controller.signal,
 		});
-
 		const durationMs = performance.now() - startTime;
 
-		if (isRecordingActive) {
+		if (isRecordingSignal()) {
 			return speedTest().speedMbps;
 		}
 
@@ -248,8 +251,26 @@ export async function runSpeedTest(): Promise<number | null> {
 			throw new Error(`Speed test returned HTTP ${response.status}`);
 		}
 
-		const calculatedSpeed = calculateSpeedMbps(chunkSize, durationMs);
-		const { qualityTier, recommendedResolution } =
+		const result = (await response.json()) as {
+			success?: boolean;
+			bytesReceived?: number;
+		};
+
+		if (!result.success || typeof result.bytesReceived !== "number") {
+			throw new Error("Invalid speed test server response");
+		}
+
+		if (result.bytesReceived < sampleBytes) {
+			throw new Error(
+				`Incomplete upload: expected ${sampleBytes} bytes, received ${result.bytesReceived}`,
+			);
+		}
+
+		const calculatedSpeed = calculateSpeedMbps(
+			result.bytesReceived,
+			durationMs,
+		);
+		const { qualityTier, recommendedResolution, recommendedLabel } =
 			determineQualityTierAndResolution(calculatedSpeed);
 
 		setSpeedTest({
@@ -257,17 +278,11 @@ export async function runSpeedTest(): Promise<number | null> {
 			speedMbps: calculatedSpeed,
 			qualityTier,
 			recommendedResolution,
+			recommendedLabel,
 			lastTested: Date.now(),
 			error: null,
 		});
 
-		try {
-			const { generalSettingsStore } = await import("~/store");
-			await generalSettingsStore.set({
-				instantModeMaxResolution: recommendedResolution,
-			});
-		} catch {}
-
 		activeSpeedTestAbort = null;
 		return calculatedSpeed;
 	} catch (error) {
@@ -292,7 +307,7 @@ export function initNetworkHealthMonitoring(): () => void {
 	void runSpeedTest();
 
 	const interval = setInterval(() => {
-		if (!isRecordingActive) {
+		if (!isRecordingSignal()) {
 			void runSpeedTest();
 		}
 	}, 45_000);
diff --git a/apps/web/app/api/desktop/[...route]/health.ts b/apps/web/app/api/desktop/[...route]/health.ts
deleted file mode 100644
index 72bb30e4747..00000000000
--- a/apps/web/app/api/desktop/[...route]/health.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { Hono } from "hono";
-import { withOptionalAuth } from "../../utils";
-
-export const app = new Hono().use(withOptionalAuth);
-
-app.get("/", (c) => {
-	return c.json({
-		status: "ok",
-		service: "cap-desktop-health",
-		timestamp: Date.now(),
-	});
-});
-
-app.post("/", async (c) => {
-	try {
-		const contentType = c.req.header("content-type") || "";
-		let bytesReceived = 0;
-
-		if (contentType.includes("application/json")) {
-			const json = await c.req.json().catch(() => ({}));
-			const payload = typeof json.payload === "string" ? json.payload : "";
-			bytesReceived = Buffer.byteLength(payload, "utf8");
-		} else {
-			const bodyBuffer = await c.req
-				.arrayBuffer()
-				.catch(() => new ArrayBuffer(0));
-			bytesReceived = bodyBuffer.byteLength;
-		}
-
-		return c.json({
-			status: "ok",
-			healthy: true,
-			bytesReceived,
-			timestamp: Date.now(),
-		});
-	} catch (error) {
-		return c.json(
-			{
-				status: "error",
-				healthy: false,
-				error: error instanceof Error ? error.message : "Health check failed",
-				timestamp: Date.now(),
-			},
-			500,
-		);
-	}
-});
-
-app.post("/speed-test", async (c) => {
-	try {
-		const body = await c.req.arrayBuffer().catch(() => new ArrayBuffer(0));
-		return c.json({
-			status: "ok",
-			bytesReceived: body.byteLength,
-			timestamp: Date.now(),
-		});
-	} catch (error) {
-		return c.json(
-			{
-				status: "error",
-				error: error instanceof Error ? error.message : "Speed test failed",
-			},
-			500,
-		);
-	}
-});
diff --git a/apps/web/app/api/desktop/[...route]/route.ts b/apps/web/app/api/desktop/[...route]/route.ts
index de142cd86c4..36857200042 100644
--- a/apps/web/app/api/desktop/[...route]/route.ts
+++ b/apps/web/app/api/desktop/[...route]/route.ts
@@ -3,7 +3,6 @@ import { handle } from "hono/vercel";
 
 import { corsMiddleware } from "../../utils";
 
-import * as health from "./health";
 import * as root from "./root";
 import * as s3Config from "./s3Config";
 import * as session from "./session";
@@ -13,7 +12,6 @@ import * as video from "./video";
 const app = new Hono()
 	.basePath("/api/desktop")
 	.use(corsMiddleware)
-	.route("/health", health.app)
 	.route("/s3/config", s3Config.app)
 	.route("/session", session.app)
 	.route("/storage", storage.app)
diff --git a/apps/web/app/api/desktop/health/route.ts b/apps/web/app/api/desktop/health/route.ts
new file mode 100644
index 00000000000..244123c5ff8
--- /dev/null
+++ b/apps/web/app/api/desktop/health/route.ts
@@ -0,0 +1,67 @@
+import {
+	HttpApi,
+	HttpApiBuilder,
+	HttpApiEndpoint,
+	HttpApiError,
+	HttpApiGroup,
+} from "@effect/platform";
+import { Effect, Layer, Schema } from "effect";
+import { apiToHandler } from "@/lib/server";
+
+const HealthResponse = Schema.Struct({
+	status: Schema.Literal("ok"),
+	timestamp: Schema.Number,
+});
+
+const SpeedTestPayload = Schema.Struct({
+	payload: Schema.String.pipe(Schema.minLength(1)),
+});
+
+const SpeedTestResponse = Schema.Struct({
+	success: Schema.Boolean,
+	bytesReceived: Schema.Number,
+	timestamp: Schema.Number,
+});
+
+class DesktopHealthApi extends HttpApi.make("DesktopHealthApi").add(
+	HttpApiGroup.make("health")
+		.add(
+			HttpApiEndpoint.get("checkHealth")`/api/desktop/health`
+				.addSuccess(HealthResponse)
+				.addError(HttpApiError.InternalServerError),
+		)
+		.add(
+			HttpApiEndpoint.post("speedTest")`/api/desktop/health`
+				.setPayload(SpeedTestPayload)
+				.addSuccess(SpeedTestResponse)
+				.addError(HttpApiError.BadRequest)
+				.addError(HttpApiError.InternalServerError),
+		),
+) {}
+
+const ApiLive = HttpApiBuilder.api(DesktopHealthApi).pipe(
+	Layer.provide(
+		HttpApiBuilder.group(DesktopHealthApi, "health", (handlers) =>
+			handlers
+				.handle("checkHealth", () =>
+					Effect.succeed({
+						status: "ok" as const,
+						timestamp: Date.now(),
+					}),
+				)
+				.handle("speedTest", ({ payload }) => {
+					const bytes = Buffer.byteLength(payload.payload, "utf8");
+					return Effect.succeed({
+						success: true,
+						bytesReceived: bytes,
+						timestamp: Date.now(),
+					});
+				}),
+		),
+	),
+);
+
+const handler = apiToHandler(ApiLive);
+
+export const GET = handler;
+export const POST = handler;

From 623cd887d771555bce99563537d659d5b1c5f39b Mon Sep 17 00:00:00 2001
From: gilnett <gilles.deschuyteneer@gmail.com>
Date: Thu, 8 Oct 2026 19:08:03 +0200
Subject: [PATCH 3/6] fix(web): harden health endpoint against DoS with payload
 limits and rate limiting

---
 apps/desktop/src/utils/network-health.test.ts | 16 +++++
 apps/web/app/api/desktop/health/route.ts      | 60 +++++++++++++++++--
 2 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
index e4d1923ddcc..e6f900205ba 100644
--- a/apps/desktop/src/utils/network-health.test.ts
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -91,4 +91,20 @@ describe("network-health speed test & quality adaptation", () => {
 
 		globalThis.fetch = originalFetch;
 	});
+
+	it("handles rate limiting and server errors gracefully during speed tests", async () => {
+		const originalFetch = globalThis.fetch;
+		globalThis.fetch = vi.fn().mockResolvedValue({
+			ok: false,
+			status: 429,
+			statusText: "Too Many Requests",
+		} as Response);
+
+		const result = await runSpeedTest();
+		expect(result).toBeNull();
+		expect(speedTest().status).toBe("error");
+		expect(speedTest().error).toContain("429");
+
+		globalThis.fetch = originalFetch;
+	});
 });
diff --git a/apps/web/app/api/desktop/health/route.ts b/apps/web/app/api/desktop/health/route.ts
index 244123c5ff8..3a7b7b35122 100644
--- a/apps/web/app/api/desktop/health/route.ts
+++ b/apps/web/app/api/desktop/health/route.ts
@@ -8,13 +8,39 @@ import {
 import { Effect, Layer, Schema } from "effect";
 import { apiToHandler } from "@/lib/server";
 
+const MAX_PAYLOAD_BYTES = 1024 * 1024;
+const MAX_PAYLOAD_CHARS = 600 * 1024;
+const RATE_LIMIT_WINDOW_MS = 60_000;
+const RATE_LIMIT_MAX_REQUESTS = 60;
+
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
+
+function isRateLimited(ip: string): boolean {
+	const now = Date.now();
+	if (rateLimitMap.size > 5_000) {
+		for (const [k, v] of rateLimitMap) {
+			if (now > v.resetAt) rateLimitMap.delete(k);
+		}
+	}
+	const entry = rateLimitMap.get(ip);
+	if (!entry || now > entry.resetAt) {
+		rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_LIMIT_WINDOW_MS });
+		return false;
+	}
+	entry.count++;
+	return entry.count > RATE_LIMIT_MAX_REQUESTS;
+}
+
 const HealthResponse = Schema.Struct({
 	status: Schema.Literal("ok"),
 	timestamp: Schema.Number,
 });
 
 const SpeedTestPayload = Schema.Struct({
-	payload: Schema.String.pipe(Schema.minLength(1)),
+	payload: Schema.String.pipe(
+		Schema.minLength(1),
+		Schema.maxLength(MAX_PAYLOAD_CHARS),
+	),
 });
 
 const SpeedTestResponse = Schema.Struct({
@@ -61,7 +87,33 @@ const ApiLive = HttpApiBuilder.api(DesktopHealthApi).pipe(
 	),
 );
 
-const handler = apiToHandler(ApiLive);
+const baseHandler = apiToHandler(ApiLive);
+
+export const GET = baseHandler;
+
+export const POST = async (req: Request) => {
+	const contentLength = req.headers.get("content-length");
+	if (contentLength && Number.parseInt(contentLength, 10) > MAX_PAYLOAD_BYTES) {
+		return new Response(JSON.stringify({ error: "Payload too large" }), {
+			status: 413,
+			headers: { "Content-Type": "application/json" },
+		});
+	}
+
+	const ip =
+		req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "unknown";
+	if (isRateLimited(ip)) {
+		return new Response(
+			JSON.stringify({ error: "Too many speed test requests" }),
+			{
+				status: 429,
+				headers: {
+					"Content-Type": "application/json",
+					"Retry-After": "60",
+				},
+			},
+		);
+	}
 
-export const GET = handler;
-export const POST = handler;
+	return baseHandler(req);
+};

From 0f73df43923162d7d01939511e5b1a2ab7838b9b Mon Sep 17 00:00:00 2001
From: gilnett <gilles.deschuyteneer@gmail.com>
Date: Thu, 8 Oct 2026 21:27:01 +0200
Subject: [PATCH 4/6] fix(desktop): eliminate latency distortion in speed test
 and restore health on recovery

---
 apps/desktop/src/utils/network-health.test.ts |  53 +++++++++
 apps/desktop/src/utils/network-health.ts      | 106 ++++++++++++------
 2 files changed, 125 insertions(+), 34 deletions(-)

diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
index e6f900205ba..1cfab4f3fb3 100644
--- a/apps/desktop/src/utils/network-health.test.ts
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -107,4 +107,57 @@ describe("network-health speed test & quality adaptation", () => {
 
 		globalThis.fetch = originalFetch;
 	});
+
+	it("clears unhealthy network health status upon successful speed test completion", async () => {
+		const originalFetch = globalThis.fetch;
+
+		// Force network health to unhealthy (simulating offline startup)
+		globalThis.fetch = vi
+			.fn()
+			.mockRejectedValue(new Error("Offline: network unreachable"));
+		await runUploadHealthCheck();
+		expect(networkHealth().status).toBe("unhealthy");
+		expect(networkHealth().error).toContain("Offline: network unreachable");
+
+		// Mock successful responses for warmup probe, latency probe, and samples
+		const mockFetch = vi
+			.fn()
+			.mockImplementation((_url: string, init?: RequestInit) => {
+				const body =
+					typeof init?.body === "string" ? JSON.parse(init.body) : {};
+				if (body.payload === "ping") {
+					return Promise.resolve({
+						ok: true,
+						json: async () => ({
+							success: true,
+							bytesReceived: 4,
+							timestamp: Date.now(),
+						}),
+					} as Response);
+				}
+				return Promise.resolve({
+					ok: true,
+					json: async () => ({
+						success: true,
+						bytesReceived: 512 * 1024,
+						timestamp: Date.now(),
+					}),
+				} as Response);
+			});
+		globalThis.fetch = mockFetch;
+
+		const speed = await runSpeedTest();
+		expect(speed).toBeGreaterThan(0);
+		expect(speedTest().status).toBe("completed");
+		expect(speedTest().error).toBeNull();
+
+		// Verify network health was restored and error cleared
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
+		// Verify that warmup probe, latency probe, and 2 samples were requested
+		expect(mockFetch).toHaveBeenCalledTimes(4);
+
+		globalThis.fetch = originalFetch;
+	});
 });
diff --git a/apps/desktop/src/utils/network-health.ts b/apps/desktop/src/utils/network-health.ts
index 8d713d916fc..3e8c7c104c5 100644
--- a/apps/desktop/src/utils/network-health.ts
+++ b/apps/desktop/src/utils/network-health.ts
@@ -205,16 +205,12 @@ export async function runSpeedTest(): Promise<number | null> {
 		const targetUrl = new URL("/api/desktop/health", baseUrl).toString();
 		const fetchFn = getHttpFetch();
 
-		const warmupPayload = JSON.stringify({
-			payload: "x".repeat(32 * 1024),
-		});
-
 		const warmupResponse = await fetchFn(targetUrl, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
 			},
-			body: warmupPayload,
+			body: JSON.stringify({ payload: "ping" }),
 			signal: controller.signal,
 		});
 
@@ -226,50 +222,83 @@ export async function runSpeedTest(): Promise<number | null> {
 			return speedTest().speedMbps;
 		}
 
-		const sampleBytes = 512 * 1024;
-		const sampleData = "a".repeat(sampleBytes);
-		const testPayload = JSON.stringify({
-			payload: sampleData,
-		});
-
-		const startTime = performance.now();
-		const response = await fetchFn(targetUrl, {
+		const rttStart = performance.now();
+		const rttResponse = await fetchFn(targetUrl, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
 			},
-			body: testPayload,
+			body: JSON.stringify({ payload: "ping" }),
 			signal: controller.signal,
 		});
-		const durationMs = performance.now() - startTime;
+		const baselineRttMs = performance.now() - rttStart;
 
-		if (isRecordingSignal()) {
-			return speedTest().speedMbps;
+		if (!rttResponse.ok) {
+			throw new Error(`Latency probe returned HTTP ${rttResponse.status}`);
 		}
 
-		if (!response.ok) {
-			throw new Error(`Speed test returned HTTP ${response.status}`);
+		if (isRecordingSignal()) {
+			return speedTest().speedMbps;
 		}
 
-		const result = (await response.json()) as {
-			success?: boolean;
-			bytesReceived?: number;
-		};
-
-		if (!result.success || typeof result.bytesReceived !== "number") {
-			throw new Error("Invalid speed test server response");
-		}
+		const sampleBytes = 512 * 1024;
+		const sampleData = "a".repeat(sampleBytes);
+		const testPayload = JSON.stringify({
+			payload: sampleData,
+		});
 
-		if (result.bytesReceived < sampleBytes) {
-			throw new Error(
-				`Incomplete upload: expected ${sampleBytes} bytes, received ${result.bytesReceived}`,
+		const sampleCount = 2;
+		const measuredSpeeds: number[] = [];
+
+		for (let i = 0; i < sampleCount; i++) {
+			if (isRecordingSignal()) {
+				return speedTest().speedMbps;
+			}
+
+			const sampleStartTime = performance.now();
+			const response = await fetchFn(targetUrl, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: testPayload,
+				signal: controller.signal,
+			});
+			const rawDurationMs = performance.now() - sampleStartTime;
+
+			if (isRecordingSignal()) {
+				return speedTest().speedMbps;
+			}
+
+			if (!response.ok) {
+				throw new Error(`Speed test returned HTTP ${response.status}`);
+			}
+
+			const result = (await response.json()) as {
+				success?: boolean;
+				bytesReceived?: number;
+			};
+
+			if (!result.success || typeof result.bytesReceived !== "number") {
+				throw new Error("Invalid speed test server response");
+			}
+
+			if (result.bytesReceived < sampleBytes) {
+				throw new Error(
+					`Incomplete upload: expected ${sampleBytes} bytes, received ${result.bytesReceived}`,
+				);
+			}
+
+			const netDurationMs = Math.max(
+				10,
+				rawDurationMs - Math.min(baselineRttMs, rawDurationMs * 0.8),
+			);
+			measuredSpeeds.push(
+				calculateSpeedMbps(result.bytesReceived, netDurationMs),
 			);
 		}
 
-		const calculatedSpeed = calculateSpeedMbps(
-			result.bytesReceived,
-			durationMs,
-		);
+		const calculatedSpeed = Math.max(...measuredSpeeds);
 		const { qualityTier, recommendedResolution, recommendedLabel } =
 			determineQualityTierAndResolution(calculatedSpeed);
 
@@ -283,6 +312,12 @@ export async function runSpeedTest(): Promise<number | null> {
 			error: null,
 		});
 
+		setNetworkHealth({
+			status: "healthy",
+			lastChecked: Date.now(),
+			error: null,
+		});
+
 		activeSpeedTestAbort = null;
 		return calculatedSpeed;
 	} catch (error) {
@@ -308,6 +343,9 @@ export function initNetworkHealthMonitoring(): () => void {
 
 	const interval = setInterval(() => {
 		if (!isRecordingSignal()) {
+			if (networkHealth().status !== "healthy") {
+				void runUploadHealthCheck();
+			}
 			void runSpeedTest();
 		}
 	}, 45_000);

From cc14a31da6b4c511fc10ce7820241e39c619286e Mon Sep 17 00:00:00 2001
From: gilnett <gilles.deschuyteneer@gmail.com>
Date: Thu, 8 Oct 2026 21:41:35 +0200
Subject: [PATCH 5/6] fix(desktop): prevent stale health checks from
 overwriting recovery and remove test narrative comments

---
 apps/desktop/src/utils/network-health.test.ts | 55 +++++++++++++++++--
 apps/desktop/src/utils/network-health.ts      | 30 ++++++----
 2 files changed, 69 insertions(+), 16 deletions(-)

diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
index 1cfab4f3fb3..c3452527954 100644
--- a/apps/desktop/src/utils/network-health.test.ts
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -111,7 +111,6 @@ describe("network-health speed test & quality adaptation", () => {
 	it("clears unhealthy network health status upon successful speed test completion", async () => {
 		const originalFetch = globalThis.fetch;
 
-		// Force network health to unhealthy (simulating offline startup)
 		globalThis.fetch = vi
 			.fn()
 			.mockRejectedValue(new Error("Offline: network unreachable"));
@@ -119,7 +118,6 @@ describe("network-health speed test & quality adaptation", () => {
 		expect(networkHealth().status).toBe("unhealthy");
 		expect(networkHealth().error).toContain("Offline: network unreachable");
 
-		// Mock successful responses for warmup probe, latency probe, and samples
 		const mockFetch = vi
 			.fn()
 			.mockImplementation((_url: string, init?: RequestInit) => {
@@ -150,14 +148,59 @@ describe("network-health speed test & quality adaptation", () => {
 		expect(speed).toBeGreaterThan(0);
 		expect(speedTest().status).toBe("completed");
 		expect(speedTest().error).toBeNull();
-
-		// Verify network health was restored and error cleared
 		expect(networkHealth().status).toBe("healthy");
 		expect(networkHealth().error).toBeNull();
-
-		// Verify that warmup probe, latency probe, and 2 samples were requested
 		expect(mockFetch).toHaveBeenCalledTimes(4);
 
 		globalThis.fetch = originalFetch;
 	});
+
+	it("prevents delayed health check failure from overwriting newer successful status", async () => {
+		const originalFetch = globalThis.fetch;
+
+		let delayedReject: ((err: Error) => void) | null = null;
+		const delayedPromise = new Promise<Response>((_, reject) => {
+			delayedReject = reject;
+		});
+		delayedPromise.catch(() => {});
+
+		globalThis.fetch = vi.fn().mockReturnValue(delayedPromise);
+		const pendingCheck = runUploadHealthCheck();
+
+		globalThis.fetch = vi
+			.fn()
+			.mockImplementation((_url: string, init?: RequestInit) => {
+				const body =
+					typeof init?.body === "string" ? JSON.parse(init.body) : {};
+				if (body.payload === "ping") {
+					return Promise.resolve({
+						ok: true,
+						json: async () => ({
+							success: true,
+							bytesReceived: 4,
+							timestamp: Date.now(),
+						}),
+					} as Response);
+				}
+				return Promise.resolve({
+					ok: true,
+					json: async () => ({
+						success: true,
+						bytesReceived: 512 * 1024,
+						timestamp: Date.now(),
+					}),
+				} as Response);
+			});
+
+		await runSpeedTest();
+		expect(networkHealth().status).toBe("healthy");
+
+		delayedReject?.(new Error("Late network timeout"));
+		await pendingCheck;
+
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
+		globalThis.fetch = originalFetch;
+	});
 });
diff --git a/apps/desktop/src/utils/network-health.ts b/apps/desktop/src/utils/network-health.ts
index 3e8c7c104c5..9746d23aa9b 100644
--- a/apps/desktop/src/utils/network-health.ts
+++ b/apps/desktop/src/utils/network-health.ts
@@ -133,6 +133,7 @@ export function calculateSpeedMbps(bytes: number, durationMs: number): number {
 }
 
 export async function runUploadHealthCheck(): Promise<boolean> {
+	const startedAt = Date.now();
 	setNetworkHealth((prev) => ({
 		...prev,
 		status: "checking",
@@ -176,11 +177,14 @@ export async function runUploadHealthCheck(): Promise<boolean> {
 	} catch (error) {
 		const errorMessage =
 			error instanceof Error ? error.message : "Upload health check failed";
-		setNetworkHealth({
-			status: "unhealthy",
-			lastChecked: Date.now(),
-			error: errorMessage,
-		});
+		const current = networkHealth();
+		if (current.lastChecked === null || current.lastChecked <= startedAt) {
+			setNetworkHealth({
+				status: "unhealthy",
+				lastChecked: Date.now(),
+				error: errorMessage,
+			});
+		}
 		return false;
 	}
 }
@@ -338,15 +342,21 @@ export async function runSpeedTest(): Promise<number | null> {
 }
 
 export function initNetworkHealthMonitoring(): () => void {
-	void runUploadHealthCheck();
-	void runSpeedTest();
+	void (async () => {
+		await runUploadHealthCheck();
+		if (!isRecordingSignal()) {
+			await runSpeedTest();
+		}
+	})();
 
-	const interval = setInterval(() => {
+	const interval = setInterval(async () => {
 		if (!isRecordingSignal()) {
 			if (networkHealth().status !== "healthy") {
-				void runUploadHealthCheck();
+				await runUploadHealthCheck();
+			}
+			if (!isRecordingSignal()) {
+				await runSpeedTest();
 			}
-			void runSpeedTest();
 		}
 	}, 45_000);
 

From 1d50783e7031e4a4b6c905b1f18842d4bdd9b3eb Mon Sep 17 00:00:00 2001
From: gilnett <gilles.deschuyteneer@gmail.com>
Date: Thu, 8 Oct 2026 22:01:25 +0200
Subject: [PATCH 6/6] fix(desktop): add stopped guard to health monitoring, fix
 test mock routing, and enforce length check

---
 apps/desktop/src/utils/network-health.test.ts | 63 +++++++++++++++++--
 apps/desktop/src/utils/network-health.ts      | 18 +++---
 apps/web/app/api/desktop/health/route.ts      | 16 ++++-
 3 files changed, 80 insertions(+), 17 deletions(-)

diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
index c3452527954..90efcc065f0 100644
--- a/apps/desktop/src/utils/network-health.test.ts
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -3,6 +3,7 @@ import {
 	calculateSpeedMbps,
 	determineQualityTierAndResolution,
 	formatResolutionLabel,
+	initNetworkHealthMonitoring,
 	isRecordingInProgress,
 	networkHealth,
 	runSpeedTest,
@@ -158,18 +159,22 @@ describe("network-health speed test & quality adaptation", () => {
 	it("prevents delayed health check failure from overwriting newer successful status", async () => {
 		const originalFetch = globalThis.fetch;
 
-		let delayedReject: ((err: Error) => void) | null = null;
+		let delayedReject!: (err: Error) => void;
+		let getEnteredMock = false;
 		const delayedPromise = new Promise<Response>((_, reject) => {
 			delayedReject = reject;
 		});
 		delayedPromise.catch(() => {});
 
-		globalThis.fetch = vi.fn().mockReturnValue(delayedPromise);
-		const pendingCheck = runUploadHealthCheck();
-
 		globalThis.fetch = vi
 			.fn()
 			.mockImplementation((_url: string, init?: RequestInit) => {
+				const method = init?.method ?? "GET";
+				if (method === "GET") {
+					getEnteredMock = true;
+					return delayedPromise;
+				}
+
 				const body =
 					typeof init?.body === "string" ? JSON.parse(init.body) : {};
 				if (body.payload === "ping") {
@@ -192,15 +197,61 @@ describe("network-health speed test & quality adaptation", () => {
 				} as Response);
 			});
 
+		const pendingCheck = runUploadHealthCheck();
+		await new Promise((resolve) => setTimeout(resolve, 15));
+		expect(getEnteredMock).toBe(true);
+
 		await runSpeedTest();
 		expect(networkHealth().status).toBe("healthy");
 
-		delayedReject?.(new Error("Late network timeout"));
-		await pendingCheck;
+		delayedReject(new Error("Late network timeout"));
+		const checkResult = await pendingCheck;
+		expect(checkResult).toBe(false);
 
 		expect(networkHealth().status).toBe("healthy");
 		expect(networkHealth().error).toBeNull();
 
 		globalThis.fetch = originalFetch;
 	});
+
+	it("stops scheduled speed tests after monitoring is disposed", async () => {
+		const originalFetch = globalThis.fetch;
+		let postCallCount = 0;
+
+		let resolveHealth!: (res: Response) => void;
+		const healthPromise = new Promise<Response>((resolve) => {
+			resolveHealth = resolve;
+		});
+
+		globalThis.fetch = vi
+			.fn()
+			.mockImplementation((_url: string, init?: RequestInit) => {
+				const method = init?.method ?? "GET";
+				if (method === "GET") {
+					return healthPromise;
+				}
+				postCallCount++;
+				return Promise.resolve({
+					ok: true,
+					json: async () => ({
+						success: true,
+						bytesReceived: 512 * 1024,
+						timestamp: Date.now(),
+					}),
+				} as Response);
+			});
+
+		const stopMonitoring = initNetworkHealthMonitoring();
+		stopMonitoring();
+
+		resolveHealth({
+			ok: true,
+			json: async () => ({ status: "ok" }),
+		} as Response);
+		await new Promise((resolve) => setTimeout(resolve, 30));
+
+		expect(postCallCount).toBe(0);
+
+		globalThis.fetch = originalFetch;
+	});
 });
diff --git a/apps/desktop/src/utils/network-health.ts b/apps/desktop/src/utils/network-health.ts
index 9746d23aa9b..6badd7b7e28 100644
--- a/apps/desktop/src/utils/network-health.ts
+++ b/apps/desktop/src/utils/network-health.ts
@@ -342,25 +342,27 @@ export async function runSpeedTest(): Promise<number | null> {
 }
 
 export function initNetworkHealthMonitoring(): () => void {
+	let isStopped = false;
+
 	void (async () => {
 		await runUploadHealthCheck();
-		if (!isRecordingSignal()) {
+		if (!isStopped && !isRecordingSignal()) {
 			await runSpeedTest();
 		}
 	})();
 
 	const interval = setInterval(async () => {
-		if (!isRecordingSignal()) {
-			if (networkHealth().status !== "healthy") {
-				await runUploadHealthCheck();
-			}
-			if (!isRecordingSignal()) {
-				await runSpeedTest();
-			}
+		if (isStopped || isRecordingSignal()) return;
+		if (networkHealth().status !== "healthy") {
+			await runUploadHealthCheck();
+		}
+		if (!isStopped && !isRecordingSignal()) {
+			await runSpeedTest();
 		}
 	}, 45_000);
 
 	return () => {
+		isStopped = true;
 		clearInterval(interval);
 		activeSpeedTestAbort?.abort();
 	};
diff --git a/apps/web/app/api/desktop/health/route.ts b/apps/web/app/api/desktop/health/route.ts
index 3a7b7b35122..84a8359aa02 100644
--- a/apps/web/app/api/desktop/health/route.ts
+++ b/apps/web/app/api/desktop/health/route.ts
@@ -92,8 +92,16 @@ const baseHandler = apiToHandler(ApiLive);
 export const GET = baseHandler;
 
 export const POST = async (req: Request) => {
-	const contentLength = req.headers.get("content-length");
-	if (contentLength && Number.parseInt(contentLength, 10) > MAX_PAYLOAD_BYTES) {
+	const contentLengthHeader = req.headers.get("content-length");
+	if (!contentLengthHeader) {
+		return new Response(JSON.stringify({ error: "Length Required" }), {
+			status: 411,
+			headers: { "Content-Type": "application/json" },
+		});
+	}
+
+	const contentLength = Number.parseInt(contentLengthHeader, 10);
+	if (Number.isNaN(contentLength) || contentLength > MAX_PAYLOAD_BYTES) {
 		return new Response(JSON.stringify({ error: "Payload too large" }), {
 			status: 413,
 			headers: { "Content-Type": "application/json" },
@@ -101,7 +109,9 @@ export const POST = async (req: Request) => {
 	}
 
 	const ip =
-		req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "unknown";
+		req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
+		req.headers.get("x-real-ip") ||
+		"unknown";
 	if (isRateLimited(ip)) {
 		return new Response(
 			JSON.stringify({ error: "Too many speed test requests" }),