able to claim 3 subdomains now

hosting-service/src/lib/safe-fetch.ts

···
 const FETCH_TIMEOUT_BLOB = 120000; // 2 minutes for blob downloads
 const MAX_RESPONSE_SIZE = 10 * 1024 * 1024; // 10MB
 const MAX_JSON_SIZE = 1024 * 1024; // 1MB
-const MAX_BLOB_SIZE = 100 * 1024 * 1024; // 100MB
+const MAX_BLOB_SIZE = 500 * 1024 * 1024; // 500MB
 const MAX_REDIRECTS = 10;
 
 function isBlockedHost(hostname: string): boolean {

hosting-service/src/lib/utils.ts

···
 
   const blobUrl = `${pdsEndpoint}/xrpc/com.atproto.sync.getBlob?did=${encodeURIComponent(did)}&cid=${encodeURIComponent(cid)}`;
 
-  // Allow up to 100MB per file blob, with 2 minute timeout
-  let content = await safeFetchBlob(blobUrl, { maxSize: 100 * 1024 * 1024, timeout: 120000 });
+  // Allow up to 500MB per file blob, with 5 minute timeout
+  let content = await safeFetchBlob(blobUrl, { maxSize: 500 * 1024 * 1024, timeout: 300000 });
 
   console.log(`[DEBUG] ${filePath}: fetched ${content.length} bytes, base64=${base64}, encoding=${encoding}, mimeType=${mimeType}`);
 

public/editor/editor.tsx

···
 	const { userInfo, loading, fetchUserInfo } = useUserInfo()
 	const { sites, sitesLoading, isSyncing, fetchSites, syncSites, deleteSite } = useSiteData()
 	const {
-		wispDomain,
+		wispDomains,
 		customDomains,
 		domainsLoading,
 		verificationStatus,
···
 		verifyDomain,
 		deleteCustomDomain,
 		mapWispDomain,
+		deleteWispDomain,
 		mapCustomDomain,
 		claimWispDomain,
 		checkWispAvailability
···
 		if (site.domains) {
 			site.domains.forEach(domainInfo => {
 				if (domainInfo.type === 'wisp') {
-					mappedDomains.add('wisp')
+					// For wisp domains, use the domain itself as the identifier
+					mappedDomains.add(`wisp:${domainInfo.domain}`)
 				} else if (domainInfo.id) {
 					mappedDomains.add(domainInfo.id)
 				}
···
 
 		setIsSavingConfig(true)
 		try {
-			// Determine which domains should be mapped/unmapped
-			const shouldMapWisp = selectedDomains.has('wisp')
-			const isCurrentlyMappedToWisp = wispDomain && wispDomain.rkey === configuringSite.rkey
+			// Handle wisp domain mappings
+			const selectedWispDomainIds = Array.from(selectedDomains).filter(id => id.startsWith('wisp:'))
+			const selectedWispDomains = selectedWispDomainIds.map(id => id.replace('wisp:', ''))
+
+			// Get currently mapped wisp domains
+			const currentlyMappedWispDomains = wispDomains.filter(
+				d => d.rkey === configuringSite.rkey
+			)
 
-			// Handle wisp domain mapping
-			if (shouldMapWisp && !isCurrentlyMappedToWisp) {
-				await mapWispDomain(configuringSite.rkey)
-			} else if (!shouldMapWisp && isCurrentlyMappedToWisp) {
-				await mapWispDomain(null)
+			// Unmap wisp domains that are no longer selected
+			for (const domain of currentlyMappedWispDomains) {
+				if (!selectedWispDomains.includes(domain.domain)) {
+					await mapWispDomain(domain.domain, null)
+				}
+			}
+
+			// Map newly selected wisp domains
+			for (const domainName of selectedWispDomains) {
+				const isAlreadyMapped = currentlyMappedWispDomains.some(d => d.domain === domainName)
+				if (!isAlreadyMapped) {
+					await mapWispDomain(domainName, configuringSite.rkey)
+				}
 			}
 
 			// Handle custom domain mappings
-			const selectedCustomDomainIds = Array.from(selectedDomains).filter(id => id !== 'wisp')
+			const selectedCustomDomainIds = Array.from(selectedDomains).filter(id => !id.startsWith('wisp:'))
 			const currentlyMappedCustomDomains = customDomains.filter(
 				d => d.rkey === configuringSite.rkey
 			)
···
 					{/* Domains Tab */}
 					<TabsContent value="domains">
 						<DomainsTab
-							wispDomain={wispDomain}
+							wispDomains={wispDomains}
 							customDomains={customDomains}
 							domainsLoading={domainsLoading}
 							verificationStatus={verificationStatus}
···
 							onAddCustomDomain={addCustomDomain}
 							onVerifyDomain={verifyDomain}
 							onDeleteCustomDomain={deleteCustomDomain}
+							onDeleteWispDomain={deleteWispDomain}
 							onClaimWispDomain={claimWispDomain}
 							onCheckWispAvailability={checkWispAvailability}
 						/>
···
 							<div className="space-y-3">
 								<p className="text-sm font-medium">Available Domains:</p>
 
-								{wispDomain && (
-									<div className="flex items-center space-x-3 p-3 border rounded-lg hover:bg-muted/30">
-										<Checkbox
-											id="wisp"
-											checked={selectedDomains.has('wisp')}
-											onCheckedChange={(checked) => {
-												const newSelected = new Set(selectedDomains)
-												if (checked) {
-													newSelected.add('wisp')
-												} else {
-													newSelected.delete('wisp')
-												}
-												setSelectedDomains(newSelected)
-											}}
-										/>
-										<Label
-											htmlFor="wisp"
-											className="flex-1 cursor-pointer"
-										>
-											<div className="flex items-center justify-between">
-												<span className="font-mono text-sm">
-													{wispDomain.domain}
-												</span>
-												<Badge variant="secondary" className="text-xs ml-2">
-													Wisp
-												</Badge>
-											</div>
-										</Label>
-									</div>
-								)}
+								{wispDomains.map((wispDomain) => {
+									const domainId = `wisp:${wispDomain.domain}`
+									return (
+										<div key={domainId} className="flex items-center space-x-3 p-3 border rounded-lg hover:bg-muted/30">
+											<Checkbox
+												id={domainId}
+												checked={selectedDomains.has(domainId)}
+												onCheckedChange={(checked) => {
+													const newSelected = new Set(selectedDomains)
+													if (checked) {
+														newSelected.add(domainId)
+													} else {
+														newSelected.delete(domainId)
+													}
+													setSelectedDomains(newSelected)
+												}}
+											/>
+											<Label
+												htmlFor={domainId}
+												className="flex-1 cursor-pointer"
+											>
+												<div className="flex items-center justify-between">
+													<span className="font-mono text-sm">
+														{wispDomain.domain}
+													</span>
+													<Badge variant="secondary" className="text-xs ml-2">
+														Wisp
+													</Badge>
+												</div>
+											</Label>
+										</div>
+									)
+								})}
 
 								{customDomains
 									.filter((d) => d.verified)
···
 										</div>
 									))}
 
-								{customDomains.filter(d => d.verified).length === 0 && !wispDomain && (
+								{customDomains.filter(d => d.verified).length === 0 && wispDomains.length === 0 && (
 									<p className="text-sm text-muted-foreground py-4 text-center">
-										No domains available. Add a custom domain or claim your wisp.place subdomain.
+										No domains available. Add a custom domain or claim a wisp.place subdomain.
 									</p>
 								)}
 							</div>

public/editor/hooks/useDomainData.ts

···
 type VerificationStatus = 'idle' | 'verifying' | 'success' | 'error'
 
 export function useDomainData() {
-	const [wispDomain, setWispDomain] = useState<WispDomain | null>(null)
+	const [wispDomains, setWispDomains] = useState<WispDomain[]>([])
 	const [customDomains, setCustomDomains] = useState<CustomDomain[]>([])
 	const [domainsLoading, setDomainsLoading] = useState(true)
 	const [verificationStatus, setVerificationStatus] = useState<{
···
 		try {
 			const response = await fetch('/api/user/domains')
 			const data = await response.json()
-			setWispDomain(data.wispDomain)
+			setWispDomains(data.wispDomains || [])
 			setCustomDomains(data.customDomains || [])
 		} catch (err) {
 			console.error('Failed to fetch domains:', err)
···
 		}
 	}
 
-	const mapWispDomain = async (siteRkey: string | null) => {
+	const mapWispDomain = async (domain: string, siteRkey: string | null) => {
 		try {
 			const response = await fetch('/api/domain/wisp/map-site', {
 				method: 'POST',
 				headers: { 'Content-Type': 'application/json' },
-				body: JSON.stringify({ siteRkey })
+				body: JSON.stringify({ domain, siteRkey })
 			})
 			const data = await response.json()
 			if (!data.success) throw new Error('Failed to map wisp domain')
···
 		}
 	}
 
+	const deleteWispDomain = async (domain: string) => {
+		if (!confirm('Are you sure you want to remove this wisp.place domain?')) {
+			return false
+		}
+
+		try {
+			const response = await fetch(`/api/domain/wisp/${encodeURIComponent(domain)}`, {
+				method: 'DELETE'
+			})
+
+			const data = await response.json()
+			if (data.success) {
+				await fetchDomains()
+				return true
+			} else {
+				throw new Error('Failed to delete domain')
+			}
+		} catch (err) {
+			console.error('Delete wisp domain error:', err)
+			alert(
+				`Failed to delete domain: ${err instanceof Error ? err.message : 'Unknown error'}`
+			)
+			return false
+		}
+	}
+
 	const mapCustomDomain = async (domainId: string, siteRkey: string | null) => {
 		try {
 			const response = await fetch(`/api/domain/custom/${domainId}/map-site`, {
···
 			console.error('Claim domain error:', err)
 			const errorMessage = err instanceof Error ? err.message : 'Unknown error'
 
-			// Handle "Already claimed" error more gracefully
-			if (errorMessage.includes('Already claimed')) {
-				alert('You have already claimed a wisp.place subdomain. Please refresh the page.')
+			// Handle domain limit error more gracefully
+			if (errorMessage.includes('Domain limit reached')) {
+				alert('You have already claimed 3 wisp.place subdomains (maximum limit).')
 				await fetchDomains()
 			} else {
 				alert(`Failed to claim domain: ${errorMessage}`)
···
 	}
 
 	return {
-		wispDomain,
+		wispDomains,
 		customDomains,
 		domainsLoading,
 		verificationStatus,
···
 		verifyDomain,
 		deleteCustomDomain,
 		mapWispDomain,
+		deleteWispDomain,
 		mapCustomDomain,
 		claimWispDomain,
 		checkWispAvailability

public/editor/tabs/DomainsTab.tsx

···
 import type { UserInfo } from '../hooks/useUserInfo'
 
 interface DomainsTabProps {
-	wispDomain: WispDomain | null
+	wispDomains: WispDomain[]
 	customDomains: CustomDomain[]
 	domainsLoading: boolean
 	verificationStatus: { [id: string]: 'idle' | 'verifying' | 'success' | 'error' }
···
 	onAddCustomDomain: (domain: string) => Promise<{ success: boolean; id?: string }>
 	onVerifyDomain: (id: string) => Promise<void>
 	onDeleteCustomDomain: (id: string) => Promise<boolean>
+	onDeleteWispDomain: (domain: string) => Promise<boolean>
 	onClaimWispDomain: (handle: string) => Promise<{ success: boolean; error?: string }>
 	onCheckWispAvailability: (handle: string) => Promise<{ available: boolean | null }>
 }
 
 export function DomainsTab({
-	wispDomain,
+	wispDomains,
 	customDomains,
 	domainsLoading,
 	verificationStatus,
···
 	onAddCustomDomain,
 	onVerifyDomain,
 	onDeleteCustomDomain,
+	onDeleteWispDomain,
 	onClaimWispDomain,
 	onCheckWispAvailability
 }: DomainsTabProps) {
···
 			<div className="space-y-4 min-h-[400px]">
 				<Card>
 					<CardHeader>
-						<CardTitle>wisp.place Subdomain</CardTitle>
+						<CardTitle>wisp.place Subdomains</CardTitle>
 						<CardDescription>
-							Your free subdomain on the wisp.place network
+							Your free subdomains on the wisp.place network (up to 3)
 						</CardDescription>
 					</CardHeader>
 					<CardContent>
···
 							<div className="flex items-center justify-center py-4">
 								<Loader2 className="w-6 h-6 animate-spin text-muted-foreground" />
 							</div>
-						) : wispDomain ? (
-							<>
-								<div className="flex flex-col gap-2 p-4 bg-muted/50 rounded-lg">
-									<div className="flex items-center gap-2">
-										<CheckCircle2 className="w-5 h-5 text-green-500" />
-										<span className="font-mono text-lg">
-											{wispDomain.domain}
-										</span>
-									</div>
-									{wispDomain.rkey && (
-										<p className="text-xs text-muted-foreground ml-7">
-											→ Mapped to site: {wispDomain.rkey}
-										</p>
-									)}
-								</div>
-								<p className="text-sm text-muted-foreground mt-3">
-									{wispDomain.rkey
-										? 'This domain is mapped to a specific site'
-										: 'This domain is not mapped to any site yet. Configure it from the Sites tab.'}
-								</p>
-							</>
 						) : (
 							<div className="space-y-4">
-								<div className="p-4 bg-muted/30 rounded-lg">
-									<p className="text-sm text-muted-foreground mb-4">
-										Claim your free wisp.place subdomain
-									</p>
-									<div className="space-y-3">
-										<div className="space-y-2">
-											<Label htmlFor="wisp-handle">Choose your handle</Label>
-											<div className="flex gap-2">
-												<div className="flex-1 relative">
-													<Input
-														id="wisp-handle"
-														placeholder="mysite"
-														value={wispHandle}
-														onChange={(e) => {
-															setWispHandle(e.target.value)
-															if (e.target.value.trim()) {
-																checkWispAvailability(e.target.value)
-															} else {
-																setWispAvailability({ available: null, checking: false })
-															}
-														}}
-														disabled={isClaimingWisp}
-														className="pr-24"
-													/>
-													<span className="absolute right-3 top-1/2 -translate-y-1/2 text-sm text-muted-foreground">
-														.wisp.place
-													</span>
+								{wispDomains.length > 0 && (
+									<div className="space-y-2">
+										{wispDomains.map((domain) => (
+											<div
+												key={domain.domain}
+												className="flex items-center justify-between p-3 border border-border rounded-lg"
+											>
+												<div className="flex flex-col gap-1 flex-1">
+													<div className="flex items-center gap-2">
+														<CheckCircle2 className="w-4 h-4 text-green-500" />
+														<span className="font-mono">
+															{domain.domain}
+														</span>
+													</div>
+													{domain.rkey && (
+														<p className="text-xs text-muted-foreground ml-6">
+															→ Mapped to site: {domain.rkey}
+														</p>
+													)}
+												</div>
+												<Button
+													variant="ghost"
+													size="sm"
+													onClick={() => onDeleteWispDomain(domain.domain)}
+												>
+													<Trash2 className="w-4 h-4" />
+												</Button>
+											</div>
+										))}
+									</div>
+								)}
+
+								{wispDomains.length < 3 && (
+									<div className="p-4 bg-muted/30 rounded-lg">
+										<p className="text-sm text-muted-foreground mb-4">
+											{wispDomains.length === 0
+												? 'Claim your free wisp.place subdomain'
+												: `Claim another wisp.place subdomain (${wispDomains.length}/3)`}
+										</p>
+										<div className="space-y-3">
+											<div className="space-y-2">
+												<Label htmlFor="wisp-handle">Choose your handle</Label>
+												<div className="flex gap-2">
+													<div className="flex-1 relative">
+														<Input
+															id="wisp-handle"
+															placeholder="mysite"
+															value={wispHandle}
+															onChange={(e) => {
+																setWispHandle(e.target.value)
+																if (e.target.value.trim()) {
+																	checkWispAvailability(e.target.value)
+																} else {
+																	setWispAvailability({ available: null, checking: false })
+																}
+															}}
+															disabled={isClaimingWisp}
+															className="pr-24"
+														/>
+														<span className="absolute right-3 top-1/2 -translate-y-1/2 text-sm text-muted-foreground">
+															.wisp.place
+														</span>
+													</div>
 												</div>
+												{wispAvailability.checking && (
+													<p className="text-xs text-muted-foreground flex items-center gap-1">
+														<Loader2 className="w-3 h-3 animate-spin" />
+														Checking availability...
+													</p>
+												)}
+												{!wispAvailability.checking && wispAvailability.available === true && (
+													<p className="text-xs text-green-600 flex items-center gap-1">
+														<CheckCircle2 className="w-3 h-3" />
+														Available
+													</p>
+												)}
+												{!wispAvailability.checking && wispAvailability.available === false && (
+													<p className="text-xs text-red-600 flex items-center gap-1">
+														<XCircle className="w-3 h-3" />
+														Not available
+													</p>
+												)}
 											</div>
-											{wispAvailability.checking && (
-												<p className="text-xs text-muted-foreground flex items-center gap-1">
-													<Loader2 className="w-3 h-3 animate-spin" />
-													Checking availability...
-												</p>
-											)}
-											{!wispAvailability.checking && wispAvailability.available === true && (
-												<p className="text-xs text-green-600 flex items-center gap-1">
-													<CheckCircle2 className="w-3 h-3" />
-													Available
-												</p>
-											)}
-											{!wispAvailability.checking && wispAvailability.available === false && (
-												<p className="text-xs text-red-600 flex items-center gap-1">
-													<XCircle className="w-3 h-3" />
-													Not available
-												</p>
-											)}
+											<Button
+												onClick={handleClaimWispDomain}
+												disabled={!wispHandle.trim() || isClaimingWisp || wispAvailability.available !== true}
+												className="w-full"
+											>
+												{isClaimingWisp ? (
+													<>
+														<Loader2 className="w-4 h-4 mr-2 animate-spin" />
+														Claiming...
+													</>
+												) : (
+													'Claim Subdomain'
+												)}
+											</Button>
 										</div>
-										<Button
-											onClick={handleClaimWispDomain}
-											disabled={!wispHandle.trim() || isClaimingWisp || wispAvailability.available !== true}
-											className="w-full"
-										>
-											{isClaimingWisp ? (
-												<>
-													<Loader2 className="w-4 h-4 mr-2 animate-spin" />
-													Claiming...
-												</>
-											) : (
-												'Claim Subdomain'
-											)}
-										</Button>
 									</div>
-								</div>
+								)}
+
+								{wispDomains.length === 3 && (
+									<div className="p-3 bg-muted/30 rounded-lg text-center">
+										<p className="text-sm text-muted-foreground">
+											You have claimed the maximum of 3 wisp.place subdomains
+										</p>
+									</div>
+								)}
 							</div>
 						)}
 					</CardContent>

src/routes/domain.ts

···
 	isValidHandle,
 	toDomain,
 	updateDomain,
+	countWispDomains,
+	deleteWispDomain,
 	getCustomDomainInfo,
 	getCustomDomainById,
 	claimCustomDomain,
···
 			try {
 				const { handle } = body as { handle?: string };
 				const normalizedHandle = (handle || "").trim().toLowerCase();
-				
+
 				if (!isValidHandle(normalizedHandle)) {
 					throw new Error("Invalid handle");
 				}
 
-				// ensure user hasn't already claimed
-				const existing = await getDomainByDid(auth.did);
-				if (existing) {
-					throw new Error("Already claimed");
-				}
-
+				// Check if user already has 3 domains (handled in claimDomain)
 				// claim in DB
 				let domain: string;
 				try {
 					domain = await claimDomain(auth.did, normalizedHandle);
 				} catch (err) {
-					throw new Error("Handle taken");
+					const message = err instanceof Error ? err.message : 'Unknown error';
+					if (message === 'domain_limit_reached') {
+						throw new Error("Domain limit reached: You can only claim up to 3 wisp.place domains");
+					}
+					throw new Error("Handle taken or error claiming domain");
 				}
 
-				// write place.wisp.domain record rkey = self
+				// write place.wisp.domain record with unique rkey
 				const agent = new Agent((url, init) => auth.session.fetchHandler(url, init));
+				const rkey = normalizedHandle; // Use handle as rkey for uniqueness
 				await agent.com.atproto.repo.putRecord({
 					repo: auth.did,
 					collection: "place.wisp.domain",
-					rkey: "self",
+					rkey,
 					record: {
 						$type: "place.wisp.domain",
 						domain,
···
 		})
 		.post('/wisp/map-site', async ({ body, auth }) => {
 			try {
-				const { siteRkey } = body as { siteRkey: string | null };
+				const { domain, siteRkey } = body as { domain: string; siteRkey: string | null };
+
+				if (!domain) {
+					throw new Error('Domain parameter required');
+				}
 
 				// Update wisp.place domain to point to this site
-				await updateWispDomainSite(auth.did, siteRkey);
+				await updateWispDomainSite(domain, siteRkey);
 
 				return { success: true };
 			} catch (err) {
 				logger.error('[Domain] Wisp domain map error', err);
 				throw new Error(`Failed to map site: ${err instanceof Error ? err.message : 'Unknown error'}`);
+			}
+		})
+		.delete('/wisp/:domain', async ({ params, auth }) => {
+			try {
+				const { domain } = params;
+
+				// Verify domain belongs to user
+				const domainLower = domain.toLowerCase().trim();
+				const info = await isDomainRegistered(domainLower);
+
+				if (!info.registered || info.type !== 'wisp') {
+					throw new Error('Domain not found');
+				}
+
+				if (info.did !== auth.did) {
+					throw new Error('Unauthorized: You do not own this domain');
+				}
+
+				// Delete from database
+				await deleteWispDomain(domainLower);
+
+				// Delete from PDS
+				const agent = new Agent((url, init) => auth.session.fetchHandler(url, init));
+				const handle = domainLower.replace(`.${process.env.BASE_DOMAIN || 'wisp.place'}`, '');
+				try {
+					await agent.com.atproto.repo.deleteRecord({
+						repo: auth.did,
+						collection: "place.wisp.domain",
+						rkey: handle,
+					});
+				} catch (err) {
+					// Record might not exist in PDS, continue anyway
+					logger.warn('[Domain] Could not delete wisp domain from PDS', err);
+				}
+
+				return { success: true };
+			} catch (err) {
+				logger.error('[Domain] Wisp domain delete error', err);
+				throw new Error(`Failed to delete domain: ${err instanceof Error ? err.message : 'Unknown error'}`);
 			}
 		})
 		.post('/custom/:id/map-site', async ({ params, body, auth }) => {

src/routes/user.ts

···
 import { requireAuth } from '../lib/wisp-auth'
 import { NodeOAuthClient } from '@atproto/oauth-client-node'
 import { Agent } from '@atproto/api'
-import { getSitesByDid, getDomainByDid, getCustomDomainsByDid, getWispDomainInfo, getDomainsBySite } from '../lib/db'
+import { getSitesByDid, getDomainByDid, getCustomDomainsByDid, getWispDomainInfo, getDomainsBySite, getAllWispDomains } from '../lib/db'
 import { syncSitesFromPDS } from '../lib/sync-sites'
 import { logger } from '../lib/logger'
 
···
 		})
 		.get('/domains', async ({ auth }) => {
 			try {
-				// Get wisp.place subdomain with mapping
-				const wispDomainInfo = await getWispDomainInfo(auth.did)
+				// Get all wisp.place subdomains with mappings (up to 3)
+				const wispDomains = await getAllWispDomains(auth.did)
 
 				// Get custom domains
 				const customDomains = await getCustomDomainsByDid(auth.did)
 
 				return {
-					wispDomain: wispDomainInfo ? {
-						domain: wispDomainInfo.domain,
-						rkey: wispDomainInfo.rkey || null
-					} : null,
+					wispDomains: wispDomains.map(d => ({
+						domain: d.domain,
+						rkey: d.rkey || null
+					})),
 					customDomains
 				}
 			} catch (err) {