Merge pull request #186 from flo-bit/some-fixes

improve custom domains

src/lib/dns.ts

···
+// Authoritative DNS verification
+// Queries authoritative nameservers directly instead of relying on cached resolvers.
+// See: https://jacob.gold/posts/stop-telling-users-their-dns-is-wrong/
+
+const TYPE_A = 1;
+const TYPE_NS = 2;
+const TYPE_CNAME = 5;
+
+interface DnsRecord {
+	type: number;
+	data: string;
+}
+
+// --- Wire format encoding ---
+
+function encodeName(name: string): Uint8Array {
+	const n = name.endsWith('.') ? name.slice(0, -1) : name;
+	const parts = n.split('.');
+	const bytes: number[] = [];
+	for (const part of parts) {
+		bytes.push(part.length);
+		for (let i = 0; i < part.length; i++) {
+			bytes.push(part.charCodeAt(i));
+		}
+	}
+	bytes.push(0);
+	return new Uint8Array(bytes);
+}
+
+function buildQuery(name: string, type: number): Uint8Array {
+	const qname = encodeName(name);
+	const msg = new Uint8Array(12 + qname.length + 4);
+	const id = (Math.random() * 0xffff) | 0;
+	msg[0] = id >> 8;
+	msg[1] = id & 0xff;
+	msg[2] = 0x01; // RD=1
+	msg[5] = 0x01; // QDCOUNT=1
+	msg.set(qname, 12);
+	const off = 12 + qname.length;
+	msg[off] = type >> 8;
+	msg[off + 1] = type & 0xff;
+	msg[off + 3] = 0x01; // CLASS IN
+	return msg;
+}
+
+// --- Wire format decoding ---
+
+function decodeName(data: Uint8Array, offset: number): [string, number] {
+	const labels: string[] = [];
+	let pos = offset;
+	let jumped = false;
+	let savedPos = 0;
+	for (let safety = 0; safety < 128 && pos < data.length; safety++) {
+		const len = data[pos];
+		if (len === 0) {
+			pos++;
+			break;
+		}
+		if ((len & 0xc0) === 0xc0) {
+			if (!jumped) savedPos = pos + 2;
+			pos = ((len & 0x3f) << 8) | data[pos + 1];
+			jumped = true;
+			continue;
+		}
+		pos++;
+		let label = '';
+		for (let i = 0; i < len && pos + i < data.length; i++) {
+			label += String.fromCharCode(data[pos + i]);
+		}
+		labels.push(label);
+		pos += len;
+	}
+	return [labels.join('.'), jumped ? savedPos : pos];
+}
+
+function parseResponse(data: Uint8Array): DnsRecord[] {
+	if (data.length < 12) return [];
+	const qdcount = (data[4] << 8) | data[5];
+	const ancount = (data[6] << 8) | data[7];
+	let offset = 12;
+
+	// Skip questions
+	for (let i = 0; i < qdcount && offset < data.length; i++) {
+		const [, off] = decodeName(data, offset);
+		offset = off + 4;
+	}
+
+	const records: DnsRecord[] = [];
+	for (let i = 0; i < ancount && offset + 10 < data.length; i++) {
+		const [, nameEnd] = decodeName(data, offset);
+		offset = nameEnd;
+		const type = (data[offset] << 8) | data[offset + 1];
+		const rdlength = (data[offset + 8] << 8) | data[offset + 9];
+		offset += 10;
+		if (offset + rdlength > data.length) break;
+
+		let value = '';
+		if (type === TYPE_A && rdlength === 4) {
+			value = `${data[offset]}.${data[offset + 1]}.${data[offset + 2]}.${data[offset + 3]}`;
+		} else if (type === TYPE_CNAME || type === TYPE_NS) {
+			[value] = decodeName(data, offset);
+		}
+		if (value) records.push({ type, data: value });
+		offset += rdlength;
+	}
+	return records;
+}
+
+// --- DNS-over-HTTPS (for finding NS records and as fallback) ---
+
+interface DohAnswer {
+	type: number;
+	data: string;
+}
+
+async function dohQuery(name: string, type: string): Promise<DohAnswer[]> {
+	const url = `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(name)}&type=${type}`;
+	const res = await fetch(url, { headers: { Accept: 'application/dns-json' } });
+	const json: { Answer?: DohAnswer[] } = await res.json();
+	return json.Answer ?? [];
+}
+
+// --- Find authoritative nameservers (walking up the domain tree) ---
+
+async function findNameservers(domain: string): Promise<string[]> {
+	let current = domain;
+	while (current.includes('.')) {
+		const answers = await dohQuery(current, 'NS');
+		const ns = answers.filter((a) => a.type === TYPE_NS).map((a) => a.data.replace(/\.$/, ''));
+		if (ns.length > 0) return ns;
+		current = current.substring(current.indexOf('.') + 1);
+	}
+	return [];
+}
+
+// --- Resolve hostname to IPs via DoH ---
+
+async function resolveToIps(hostname: string): Promise<string[]> {
+	const answers = await dohQuery(hostname, 'A');
+	return answers.filter((a) => a.type === TYPE_A).map((a) => a.data);
+}
+
+// --- Query nameserver directly via TCP (cloudflare:sockets) ---
+
+async function queryViaTcp(serverIp: string, name: string, type: number): Promise<DnsRecord[]> {
+	// @ts-expect-error: cloudflare:sockets is only available in Workers runtime
+	const { connect } = await import('cloudflare:sockets');
+
+	const query = buildQuery(name, type);
+	const tcpMsg = new Uint8Array(query.length + 2);
+	tcpMsg[0] = (query.length >> 8) & 0xff;
+	tcpMsg[1] = query.length & 0xff;
+	tcpMsg.set(query, 2);
+
+	const socket = connect({ hostname: serverIp, port: 53 });
+	const writer = socket.writable.getWriter();
+	await writer.write(tcpMsg);
+	writer.releaseLock();
+
+	const reader = socket.readable.getReader();
+	let buffer = new Uint8Array(0);
+	let responseLen = -1;
+
+	const timeout = setTimeout(() => socket.close(), 5000);
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			const chunk = new Uint8Array(value as ArrayBuffer);
+			const newBuf = new Uint8Array(buffer.length + chunk.length);
+			newBuf.set(buffer);
+			newBuf.set(chunk, buffer.length);
+			buffer = newBuf;
+
+			if (responseLen === -1 && buffer.length >= 2) {
+				responseLen = (buffer[0] << 8) | buffer[1];
+			}
+			if (responseLen >= 0 && buffer.length >= responseLen + 2) break;
+		}
+	} finally {
+		clearTimeout(timeout);
+		reader.releaseLock();
+		socket.close();
+	}
+
+	if (buffer.length < 2) return [];
+	return parseResponse(buffer.slice(2, 2 + responseLen));
+}
+
+// --- Query with TCP, fall back to DoH for local dev ---
+
+async function queryAuthoritative(
+	serverIp: string,
+	name: string,
+	type: number
+): Promise<DnsRecord[]> {
+	try {
+		return await queryViaTcp(serverIp, name, type);
+	} catch {
+		// cloudflare:sockets not available (local dev) — fall back to DoH
+		const typeStr = type === TYPE_A ? 'A' : type === TYPE_CNAME ? 'CNAME' : 'NS';
+		return (await dohQuery(name, typeStr)).map((a) => ({ type: a.type, data: a.data }));
+	}
+}
+
+// --- Main verification ---
+
+export interface DnsVerifyResult {
+	ok: boolean;
+	error?: string;
+	hint?: string;
+}
+
+function normalize(s: string): string {
+	return s.replace(/\.$/, '').toLowerCase();
+}
+
+export async function verifyDomainDns(
+	domain: string,
+	expectedTarget: string
+): Promise<DnsVerifyResult> {
+	// Find authoritative nameservers
+	const nameservers = await findNameservers(domain);
+	if (nameservers.length === 0) {
+		return { ok: false, error: `Could not find nameservers for "${domain}".` };
+	}
+
+	// Try each nameserver until one responds
+	for (const ns of nameservers) {
+		const ips = await resolveToIps(ns);
+		if (ips.length === 0) continue;
+
+		const nsIp = ips[0];
+
+		// Check CNAME records
+		const cnameRecords = await queryAuthoritative(nsIp, domain, TYPE_CNAME);
+		const cnames = cnameRecords.filter((r) => r.type === TYPE_CNAME);
+
+		if (cnames.length > 0) {
+			if (cnames.length > 1) {
+				return {
+					ok: false,
+					error: `Multiple CNAME records found for "${domain}": ${cnames.map((r) => r.data).join(', ')}. Remove duplicate records so only one remains.`
+				};
+			}
+			const got = normalize(cnames[0].data);
+			const want = normalize(expectedTarget);
+			if (got !== want) {
+				return {
+					ok: false,
+					error: `CNAME for "${domain}" points to "${got}" instead of "${want}".`,
+					hint: `If you're using Cloudflare, make sure the proxy (orange cloud) is turned off for this record.`
+				};
+			}
+			return { ok: true };
+		}
+
+		// No CNAME — check A records (root/apex domains with CNAME flattening or A records)
+		const aRecords = await queryAuthoritative(nsIp, domain, TYPE_A);
+		const aValues = aRecords.filter((r) => r.type === TYPE_A);
+
+		if (aValues.length > 0) {
+			// Resolve the expected target to get its IPs for comparison
+			const expectedIps = await resolveToIps(expectedTarget);
+			if (expectedIps.length === 0) {
+				return {
+					ok: false,
+					error: `Could not resolve "${expectedTarget}" to verify A records.`
+				};
+			}
+			const expectedSet = new Set(expectedIps);
+			const unexpected = aValues.filter((r) => !expectedSet.has(r.data));
+			if (unexpected.length > 0) {
+				return {
+					ok: false,
+					error: `A record(s) for "${domain}" include unexpected IPs: ${unexpected.map((r) => r.data).join(', ')}. Expected only IPs matching "${expectedTarget}" (${expectedIps.join(', ')}).`,
+					hint: `If you're using Cloudflare, make sure the proxy (orange cloud) is turned off for this record.`
+				};
+			}
+			return { ok: true };
+		}
+
+		// Neither CNAME nor A found
+		return {
+			ok: false,
+			error: `No CNAME or A record found for "${domain}". Please add a CNAME record pointing to "${expectedTarget}".`
+		};
+	}
+
+	return {
+		ok: false,
+		error: `Could not reach any nameserver for "${domain}".`
+	};
+}

src/lib/website/Account.svelte

···
 		</Popover>
 	</div>
 
-	<CustomDomainModal />
+	<CustomDomainModal publicationUrl={data.publication?.url} />
 {/if}

src/lib/website/CustomDomainModal.svelte

···
 </script>
 
 <script lang="ts">
-	import { putRecord, getRecord } from '$lib/atproto/methods';
+	import { putRecord, getRecord, getHandleOrDid } from '$lib/atproto/methods';
 	import { user } from '$lib/atproto';
 	import { Button, Input } from '@foxui/core';
 	import Modal from '$lib/components/modal/Modal.svelte';
 	import { launchConfetti } from '@foxui/visual';
 
-	let step: 'input' | 'instructions' | 'verifying' | 'success' | 'error' = $state('input');
+	let { publicationUrl }: { publicationUrl?: string } = $props();
+
+	let currentDomain = $derived(
+		publicationUrl?.startsWith('https://') && !publicationUrl.includes('blento.app')
+			? publicationUrl.replace('https://', '')
+			: ''
+	);
+
+	let step: 'current' | 'input' | 'instructions' | 'verifying' | 'removing' | 'success' | 'error' =
+		$state('input');
 	let domain = $state('');
 	let errorMessage = $state('');
+	let errorHint = $state('');
 
 	$effect(() => {
-		if (!customDomainModalState.visible) {
+		if (customDomainModalState.visible) {
+			step = currentDomain ? 'current' : 'input';
+		} else {
 			step = 'input';
 			domain = '';
 			errorMessage = '';
+			errorHint = '';
 		}
 	});
 
+	async function removeDomain() {
+		step = 'removing';
+		try {
+			const existing = await getRecord({
+				collection: 'site.standard.publication',
+				rkey: 'blento.self'
+			});
+
+			if (existing?.value) {
+				const { url: _url, ...rest } = existing.value as Record<string, unknown>;
+				await putRecord({
+					collection: 'site.standard.publication',
+					rkey: 'blento.self',
+					record: rest
+				});
+			}
+
+			step = 'input';
+		} catch (err: unknown) {
+			errorMessage = err instanceof Error ? err.message : String(err);
+			step = 'error';
+		}
+	}
+
 	function goToInstructions() {
 		if (!domain.trim()) return;
 		step = 'instructions';
···
 	async function verify() {
 		step = 'verifying';
 		try {
+			// Step 1: Verify DNS records
+			const dnsRes = await fetch('/api/verify-domain', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ domain })
+			});
+
+			const dnsData = await dnsRes.json();
+
+			if (!dnsRes.ok || dnsData.error) {
+				errorMessage = dnsData.error;
+				errorHint = dnsData.hint || '';
+				step = 'error';
+				return;
+			}
+
+			// Step 2: Write URL to ATProto profile
 			const existing = await getRecord({
 				collection: 'site.standard.publication',
 				rkey: 'blento.self'
···
 				}
 			});
 
-			const res = await fetch('/api/verify-domain', {
+			// Step 3: Activate domain in KV (server verifies profile has the URL)
+			const activateRes = await fetch('/api/activate-domain', {
 				method: 'POST',
 				headers: { 'Content-Type': 'application/json' },
 				body: JSON.stringify({ did: user.did, domain })
 			});
 
-			const data = await res.json();
+			const activateData = await activateRes.json();
 
-			if (data.success) {
-				launchConfetti();
-				step = 'success';
-			} else if (data.error) {
-				errorMessage = data.error;
+			if (!activateRes.ok || activateData.error) {
+				errorMessage = activateData.error;
+				errorHint = '';
 				step = 'error';
+				return;
 			}
+
+			// Refresh cached profile
+			if (user.profile) {
+				fetch(`/${getHandleOrDid(user.profile)}/api/refresh`).catch(() => {});
+			}
+
+			launchConfetti();
+			step = 'success';
 		} catch (err: unknown) {
 			errorMessage = err instanceof Error ? err.message : String(err);
 			step = 'error';
···
 </script>
 
 <Modal bind:open={customDomainModalState.visible}>
-	{#if step === 'input'}
+	{#if step === 'current'}
+		<h3 class="text-base-900 dark:text-base-100 font-semibold" id="custom-domain-modal-title">
+			Custom Domain
+		</h3>
+
+		<div
+			class="bg-base-200 dark:bg-base-700 mt-2 flex items-center justify-between rounded-2xl px-3 py-2 font-mono text-sm"
+		>
+			<span>{currentDomain}</span>
+		</div>
+
+		<div class="mt-4 flex gap-2">
+			<Button variant="ghost" onclick={removeDomain}>Remove</Button>
+			<Button variant="ghost" onclick={() => (step = 'input')}>Change</Button>
+			<Button onclick={() => customDomainModalState.hide()}>Close</Button>
+		</div>
+	{:else if step === 'input'}
 		<h3 class="text-base-900 dark:text-base-100 font-semibold" id="custom-domain-modal-title">
 			Custom Domain
 		</h3>
···
 			</svg>
 			<span class="text-base-600 dark:text-base-400 text-sm">Verifying...</span>
 		</div>
+	{:else if step === 'removing'}
+		<h3 class="text-base-900 dark:text-base-100 font-semibold" id="custom-domain-modal-title">
+			Removing...
+		</h3>
+
+		<div class="mt-4 flex items-center gap-2">
+			<svg
+				class="text-base-500 size-5 animate-spin"
+				xmlns="http://www.w3.org/2000/svg"
+				fill="none"
+				viewBox="0 0 24 24"
+			>
+				<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"
+				></circle>
+				<path
+					class="opacity-75"
+					fill="currentColor"
+					d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+				></path>
+			</svg>
+			<span class="text-base-600 dark:text-base-400 text-sm">Removing domain...</span>
+		</div>
 	{:else if step === 'success'}
 		<h3 class="text-base-900 dark:text-base-100 font-semibold" id="custom-domain-modal-title">
 			Domain verified!
···
 		<p class="mt-2 text-sm text-red-500 dark:text-red-400">
 			{errorMessage}
 		</p>
+		{#if errorHint}
+			<p class="mt-1 text-sm font-bold text-red-500 dark:text-red-400">
+				{errorHint}
+			</p>
+		{/if}
 
 		<div class="mt-4 flex gap-2">
 			<Button variant="ghost" onclick={() => customDomainModalState.hide()}>Close</Button>

src/routes/api/activate-domain/+server.ts

···
+import { json } from '@sveltejs/kit';
+import { isDid } from '@atcute/lexicons/syntax';
+import { getRecord } from '$lib/atproto/methods';
+import type { Did } from '@atcute/lexicons';
+
+export async function POST({ request, platform }) {
+	let body: { did: string; domain: string };
+	try {
+		body = await request.json();
+	} catch {
+		return json({ error: 'Invalid JSON body' }, { status: 400 });
+	}
+
+	const { did, domain } = body;
+
+	if (!did || !domain) {
+		return json({ error: 'Missing required fields: did, domain' }, { status: 400 });
+	}
+
+	if (!isDid(did)) {
+		return json({ error: 'Invalid DID format' }, { status: 400 });
+	}
+
+	// Validate domain format
+	if (
+		!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)+$/.test(
+			domain
+		)
+	) {
+		return json({ error: 'Invalid domain format' }, { status: 400 });
+	}
+
+	// Verify the user's ATProto profile has this domain set
+	try {
+		const record = await getRecord({
+			did: did as Did,
+			collection: 'site.standard.publication',
+			rkey: 'blento.self'
+		});
+
+		const url = (record?.value as Record<string, unknown>)?.url;
+		if (url !== `https://${domain}`) {
+			return json(
+				{
+					error: `Profile does not have this domain set. Expected "https://${domain}" but got "${url || '(none)'}".`
+				},
+				{ status: 403 }
+			);
+		}
+	} catch {
+		return json({ error: 'Failed to verify profile record.' }, { status: 500 });
+	}
+
+	// Write to CUSTOM_DOMAINS KV
+	const kv = platform?.env?.CUSTOM_DOMAINS;
+	if (!kv) {
+		return json({ error: 'KV storage not available.' }, { status: 500 });
+	}
+
+	try {
+		await kv.put(domain.toLowerCase(), did);
+	} catch {
+		return json({ error: 'Failed to register domain.' }, { status: 500 });
+	}
+
+	return json({ success: true });
+}

src/routes/api/reloadRecent/+server.ts

···
-import { getDetailedProfile } from '$lib/atproto';
-import { createCache } from '$lib/cache';
-import { json } from '@sveltejs/kit';
-import type { AppBskyActorDefs } from '@atcute/bluesky';
-
-export async function GET({ platform }) {
-	const cache = createCache(platform);
-	if (!cache) return json('no cache');
-
-	const existingUsers = await cache.get('meta', 'updatedBlentos');
-
-	const existingUsersArray: AppBskyActorDefs.ProfileViewDetailed[] = existingUsers
-		? JSON.parse(existingUsers)
-		: [];
-
-	const existingUsersSet = new Set(existingUsersArray.map((v) => v.did));
-
-	const newProfilesPromises: Promise<AppBskyActorDefs.ProfileViewDetailed | undefined>[] = [];
-	for (const did of Array.from(existingUsersSet)) {
-		const profile = getDetailedProfile({ did });
-		newProfilesPromises.push(profile);
-		if (newProfilesPromises.length > 20) break;
-	}
-
-	const newProfiles = await Promise.all(newProfilesPromises);
-
-	await cache.put('meta', 'updatedBlentos', JSON.stringify(newProfiles));
-
-	return json('ok');
-}

src/routes/api/update/+server.ts

···
-import { createCache } from '$lib/cache';
-import { getCache, loadData } from '$lib/website/load';
-import { env } from '$env/dynamic/private';
-import { json } from '@sveltejs/kit';
-import type { AppBskyActorDefs } from '@atcute/bluesky';
-
-export async function GET({ platform }) {
-	const cache = createCache(platform);
-	if (!cache) return json('no cache');
-
-	const existingUsers = await cache.get('meta', 'updatedBlentos');
-
-	const existingUsersArray: AppBskyActorDefs.ProfileViewDetailed[] = existingUsers
-		? JSON.parse(existingUsers)
-		: [];
-
-	const existingUsersHandle = existingUsersArray.map((v) => v.handle);
-
-	for (const handle of existingUsersHandle) {
-		if (!handle) continue;
-
-		try {
-			const cached = await getCache(handle, 'self', cache);
-			if (!cached) await loadData(handle, cache, true, 'self', env);
-		} catch (error) {
-			console.error(error);
-			return json('error');
-		}
-	}
-
-	return json('ok');
-}

src/routes/api/verify-domain/+server.ts

···
 import { json } from '@sveltejs/kit';
-import type { Did } from '@atcute/lexicons';
-import { getClient, getRecord } from '$lib/atproto/methods';
+import { verifyDomainDns } from '$lib/dns';
 
-export async function POST({ request, platform }) {
-	let body: { did: string; domain: string };
+const EXPECTED_TARGET = 'blento-proxy.fly.dev';
+
+export async function POST({ request }) {
+	let body: { domain: string };
 	try {
 		body = await request.json();
 	} catch {
 		return json({ error: 'Invalid JSON body' }, { status: 400 });
 	}
 
-	const { did, domain } = body;
+	const { domain } = body;
 
-	if (!did || !domain) {
-		return json({ error: 'Missing required fields: did and domain' }, { status: 400 });
+	if (!domain) {
+		return json({ error: 'Missing required field: domain' }, { status: 400 });
 	}
 
 	// Validate domain format
···
 		return json({ error: 'Invalid domain format' }, { status: 400 });
 	}
 
-	// Check the user's site.standard.publication record
-	try {
-		const client = await getClient({ did: did as Did });
-		const record = await getRecord({
-			did: did as Did,
-			collection: 'site.standard.publication',
-			rkey: 'blento.self',
-			client
-		});
-
-		const recordUrl = record?.value?.url;
-		const expectedUrl = `https://${domain}`;
-
-		if (recordUrl !== expectedUrl) {
-			return json(
-				{
-					error: `Publication record URL does not match. Expected "${expectedUrl}", got "${recordUrl || '(not set)'}".`
-				},
-				{ status: 400 }
-			);
-		}
-	} catch {
-		return json(
-			{ error: 'Could not read site.standard.publication record. Make sure it exists.' },
-			{ status: 400 }
-		);
-	}
-
-	// Verify CNAME via DNS-over-HTTPS
+	// Verify DNS by querying authoritative nameservers directly.
+	// This gives instant, accurate results instead of relying on cached resolvers.
+	// Checks CNAME for subdomains and A records for root/apex domains.
+	// See: https://jacob.gold/posts/stop-telling-users-their-dns-is-wrong/
 	try {
-		const dohUrl = `https://mozilla.cloudflare-dns.com/dns-query?name=${encodeURIComponent(domain)}&type=CNAME`;
-		const dnsRes = await fetch(dohUrl, {
-			headers: { Accept: 'application/dns-json' }
-		});
-		const dnsData = await dnsRes.json();
-
-		const cnameTarget = 'blento-proxy.fly.dev.';
-		const cnameTargetNoDot = 'blento-proxy.fly.dev';
-
-		const hasCname = dnsData.Answer?.some(
-			(answer: { type: number; data: string }) =>
-				answer.type === 5 && (answer.data === cnameTarget || answer.data === cnameTargetNoDot)
-		);
-
-		if (!hasCname) {
-			return json(
-				{
-					error: `CNAME record not found. Please set a CNAME for "${domain}" pointing to "blento-proxy.fly.dev".`
-				},
-				{ status: 400 }
-			);
+		const result = await verifyDomainDns(domain, EXPECTED_TARGET);
+		if (!result.ok) {
+			return json({ error: result.error, hint: result.hint }, { status: 400 });
 		}
 	} catch {
 		return json({ error: 'Failed to verify DNS records.' }, { status: 500 });
-	}
-
-	// Write to CUSTOM_DOMAINS KV
-	const kv = platform?.env?.CUSTOM_DOMAINS;
-	if (!kv) {
-		return json({ error: 'Domain storage is not available.' }, { status: 500 });
-	}
-
-	try {
-		await kv.put(domain, did);
-	} catch {
-		return json({ error: 'Failed to save custom domain.' }, { status: 500 });
 	}
 
 	return json({ success: true });

vite.config.ts

···
 		port: 5179
 	},
 	build: {
-		sourcemap: true
+		sourcemap: true,
+		rollupOptions: {
+			external: ['cloudflare:sockets']
+		}
 	}
 });