refactor: add DRY pagination utility for AT Protocol

- Create reusable fetchAllRecords utility with cursor-based pagination
- Add fetchAllUserRecords convenience function
- Refactor archive page to use new pagination utilities
- Ensures all posts are fetched (not limited to 100)
- Add proper TypeScript types (AtProtoRecord interface)

src/lib/components/layout/main/card/LinkCard.svelte

···
 			{/if}
 
 			<!-- 👇 Title is always below the badges -->
-			<h3 class="overflow-wrap-anywhere font-semibold wrap-break-word text-ink-900 dark:text-ink-50">
+			<h3
+				class="overflow-wrap-anywhere font-semibold wrap-break-word text-ink-900 dark:text-ink-50"
+			>
 				{title}
 			</h3>
 

src/lib/services/atproto/pagination/fetchAllRecords.ts

···
+import { withFallback } from '$lib/services/atproto/agents';
+import { PUBLIC_ATPROTO_DID } from '$env/static/public';
+
+/**
+ * Configuration for fetching paginated records
+ */
+export interface FetchRecordsConfig {
+	/** The repository DID to fetch from */
+	repo: string;
+	/** The AT Protocol collection to fetch from */
+	collection: string;
+	/** Number of records to fetch per page (max 100) */
+	limit?: number;
+	/** Optional fetch function for SSR */
+	fetchFn?: typeof fetch;
+}
+
+/**
+ * Type for AT Protocol record response
+ */
+export interface AtProtoRecord<T = any> {
+	uri: string;
+	value: T;
+	cid?: string;
+}
+
+/**
+ * Generic function to fetch all records from an AT Protocol collection with automatic pagination.
+ *
+ * @param config - Configuration object for the fetch operation
+ * @returns Promise resolving to array of all records
+ *
+ * @example
+ * ```ts
+ * const posts = await fetchAllRecords({
+ *   repo: PUBLIC_ATPROTO_DID,
+ *   collection: 'com.whtwnd.blog.entry',
+ *   fetchFn: fetch
+ * });
+ * ```
+ */
+export async function fetchAllRecords<T = any>(
+	config: FetchRecordsConfig
+): Promise<AtProtoRecord<T>[]> {
+	const { repo, collection, limit = 100, fetchFn } = config;
+	const allRecords: AtProtoRecord<T>[] = [];
+
+	let cursor: string | undefined;
+
+	try {
+		do {
+			const records = await withFallback(
+				repo,
+				async (agent) => {
+					const response = await agent.com.atproto.repo.listRecords({
+						repo,
+						collection,
+						limit,
+						cursor
+					});
+					cursor = response.data.cursor;
+					return response.data.records;
+				},
+				true,
+				fetchFn
+			);
+
+			allRecords.push(...(records as AtProtoRecord<T>[]));
+		} while (cursor);
+	} catch (error) {
+		console.warn(`Failed to fetch records from ${collection}:`, error);
+		throw error;
+	}
+
+	return allRecords;
+}
+
+/**
+ * Convenience function to fetch all records from the configured user's repository
+ */
+export async function fetchAllUserRecords<T = any>(
+	collection: string,
+	fetchFn?: typeof fetch,
+	limit?: number
+): Promise<AtProtoRecord<T>[]> {
+	return fetchAllRecords<T>({
+		repo: PUBLIC_ATPROTO_DID,
+		collection,
+		limit,
+		fetchFn
+	});
+}

src/lib/services/atproto/pagination/index.ts

···
+export { fetchAllRecords, fetchAllUserRecords } from './fetchAllRecords';
+export type { FetchRecordsConfig, AtProtoRecord } from './fetchAllRecords';

src/routes/archive/+page.ts

···
 import type { PageLoad } from './$types';
 import { createSiteMeta, type SiteMetadata } from '$lib/helper/siteMeta';
-import { withFallback } from '$lib/services/atproto/agents';
+import { fetchAllUserRecords } from '$lib/services/atproto/pagination';
 import { PUBLIC_ATPROTO_DID } from '$env/static/public';
 import type { BlogPost } from '$lib/services/atproto';
 
 /**
- * Fetches ALL blog posts from WhiteWind and Leaflet (no limit)
+ * Fetches ALL blog posts from WhiteWind and Leaflet with proper pagination
  */
 async function fetchAllBlogPosts(fetchFn?: typeof fetch): Promise<BlogPost[]> {
 	const posts: BlogPost[] = [];
 
-	// Fetch WhiteWind posts
+	// Fetch WhiteWind posts with pagination
 	try {
-		const whiteWindRecords = await withFallback(
-			PUBLIC_ATPROTO_DID,
-			async (agent) => {
-				const response = await agent.com.atproto.repo.listRecords({
-					repo: PUBLIC_ATPROTO_DID,
-					collection: 'com.whtwnd.blog.entry',
-					limit: 100
-				});
-				return response.data.records;
-			},
-			true,
-			fetchFn
-		);
+		const whiteWindRecords = await fetchAllUserRecords('com.whtwnd.blog.entry', fetchFn);
 
 		for (const record of whiteWindRecords) {
 			const value = record.value as any;
···
 		console.warn('Failed to fetch WhiteWind posts:', error);
 	}
 
-	// Fetch Leaflet publications and documents
+	// Fetch Leaflet publications and documents with pagination
 	try {
-		// Get all publications first
-		const publicationsRecords = await withFallback(
-			PUBLIC_ATPROTO_DID,
-			async (agent) => {
-				const response = await agent.com.atproto.repo.listRecords({
-					repo: PUBLIC_ATPROTO_DID,
-					collection: 'pub.leaflet.publication',
-					limit: 100
-				});
-				return response.data.records;
-			},
-			true,
-			fetchFn
-		);
+		// Fetch all publications
+		const publicationsRecords = await fetchAllUserRecords('pub.leaflet.publication', fetchFn);
 
 		const publicationsMap = new Map<string, { name: string; basePath?: string }>();
 		for (const pubRecord of publicationsRecords) {
···
 		}
 
 		// Fetch all Leaflet documents
-		const leafletDocsRecords = await withFallback(
-			PUBLIC_ATPROTO_DID,
-			async (agent) => {
-				const response = await agent.com.atproto.repo.listRecords({
-					repo: PUBLIC_ATPROTO_DID,
-					collection: 'pub.leaflet.document',
-					limit: 100
-				});
-				return response.data.records;
-			},
-			true,
-			fetchFn
-		);
+		const leafletDocsRecords = await fetchAllUserRecords('pub.leaflet.document', fetchFn);
 
 		for (const record of leafletDocsRecords) {
 			const value = record.value as any;