bunch of changes

lib/index.ts

···
 export { leafletLiveLoader } from "./leaflet-live-loader.js";
+export { leafletStaticLoader } from "./leaftlet-static-loader.js";

lib/leaflet-live-loader.ts

···
 	EntryFilter,
 	LeafletDocumentRecord,
 	LeafletDocumentView,
-	LeafletLoaderOptions,
+	LiveLeafletLoaderOptions,
 } from "./types.js";
 import {
 	getLeafletDocuments,
 	getSingleLeafletDocument,
+	leafletBlocksToHTML,
 	leafletDocumentRecordToView,
 	LiveLoaderError,
 	resolveMiniDoc,
···
 } from "./utils.js";
 
 export function leafletLiveLoader(
-	options: LeafletLoaderOptions,
+	options: LiveLeafletLoaderOptions,
 ): LiveLoader<
 	LeafletDocumentView,
 	EntryFilter,
···
 				const pds_url = await resolveMiniDoc(repo);
 				const agent = new Agent({ service: pds_url });
 
-				const documents = await getLeafletDocuments({
+				const { documents } = await getLeafletDocuments({
 					agent,
 					repo,
 					reverse: filter?.reverse,
···
 								cid: document.cid,
 								value: document.value as unknown as LeafletDocumentRecord,
 							}),
+							rendered: {
+								html: leafletBlocksToHTML({
+									id,
+									uri: document.uri,
+									cid: document.cid,
+									value: document.value as unknown as LeafletDocumentRecord,
+								}),
+							},
 						};
 					}),
 				};
···
 					repo,
 				});
 
+				const cid = document?.cid?.toString() ?? "";
+
 				return {
 					id: filter.id,
 					data: leafletDocumentRecordToView({
 						uri: document.uri,
-						cid: document.cid?.toString() ?? "",
+						cid,
 						value: document.value as unknown as LeafletDocumentRecord,
 					}),
+					rendered: {
+						html: leafletBlocksToHTML({
+							id: filter.id,
+							uri: document.uri,
+							cid,
+							value: document.value as unknown as LeafletDocumentRecord,
+						}),
+					},
 				};
 			} catch {
 				return {

lib/leaftlet-static-loader.ts

···
+import { Agent } from "@atproto/api";
+import { isDid } from "@atproto/did";
+import type { Loader, LoaderContext } from "astro/loaders";
+import { LeafletDocumentSchema } from "schema.js";
+import type {
+	LeafletDocumentRecord,
+	StaticLeafletLoaderOptions,
+} from "types.js";
+import {
+	LiveLoaderError,
+	resolveMiniDoc,
+	getLeafletDocuments,
+	uriToRkey,
+	leafletDocumentRecordToView,
+	leafletBlocksToHTML,
+} from "utils.js";
+
+export function leafletStaticLoader(
+	options: StaticLeafletLoaderOptions,
+): Loader {
+	const { repo, limit } = options;
+
+	if (!repo || typeof repo !== "string") {
+		throw new LiveLoaderError(
+			"missing or invalid did",
+			"MISSING_OR_INVALID_DID",
+		);
+	}
+
+	// not a valid did
+	if (!isDid(repo)) {
+		throw new LiveLoaderError("invalid did", "INVALID_DID");
+	}
+
+	return {
+		name: "static-leaflet-loader-astro",
+		schema: LeafletDocumentSchema,
+		load: async ({
+			store,
+			logger,
+			generateDigest,
+			parseData,
+		}: LoaderContext) => {
+			try {
+				logger.info("fetching latest leaflet documents");
+				const pds_url = await resolveMiniDoc(repo);
+				const agent = new Agent({ service: pds_url });
+
+				let cursor: string | undefined;
+				let count = 0;
+
+				fetching: do {
+					const { documents, cursor: documentsCursor } =
+						await getLeafletDocuments({
+							agent,
+							repo,
+							cursor,
+							limit: 100,
+						});
+					for (const document of documents) {
+						if (limit && count >= limit) {
+							count++;
+							break fetching;
+						}
+						count++;
+
+						const id = uriToRkey(document.uri);
+						const digest = generateDigest(document.value);
+						store.set({
+							id,
+							data: await parseData({
+								id,
+								data: JSON.parse(
+									JSON.stringify(
+										leafletDocumentRecordToView({
+											uri: document.uri,
+											cid: document.cid,
+											value: document.value as unknown as LeafletDocumentRecord,
+										}),
+									),
+								),
+							}),
+							digest,
+							rendered: {
+								html: leafletBlocksToHTML({
+									id,
+									uri: document.uri,
+									cid: document.cid,
+									value: document.value as unknown as LeafletDocumentRecord,
+								}),
+							},
+						});
+					}
+					cursor = documentsCursor;
+					logger.info(`Fetched ${count} posts`);
+				} while (cursor);
+			} catch (error) {
+				logger.error(
+					`There was an error fetching the leaflet documents: ${(error as Error).message}`,
+				);
+			}
+		},
+	};
+}

lib/schema.ts

···
+import { z } from "astro/zod";
+
+export const LeafletDocumentSchema = z.object({
+	rkey: z.string(),
+	cid: z.string(),
+	title: z.string(),
+	description: z.string(),
+	author: z.string(),
+	publication: z.string(),
+	publishedAt: z.string(),
+});

lib/types.ts

···
 import type { Agent } from "@atproto/api";
 import type { PubLeafletRichtextFacet } from "./lexicons/index.js";
 
-export interface LeafletLoaderOptions {
+export interface LiveLeafletLoaderOptions {
+	/**
+	 * @description Your repo is your DID (did:plc... or did:web...). You can find this information using: https://pdsls.dev
+	 */
+	repo: string;
+}
+
+export interface StaticLeafletLoaderOptions {
 	/**
-	 * @description Your repo is either your handle (@you.some.url) or your DID (did:plc... or did:web...). You can find this information using: https://pdsls.dev
+	 * @description Your repo is your DID (did:plc... or did:web...). You can find this information using: https://pdsls.dev
 	 */
 	repo: string;
+	filter?: string;
+	/**
+	 * @default 50
+	 */
+	limit?: number;
 }
 
 export interface LeafletDocumentRecord {
···
 	rkey: string;
 	cid: string;
 	title: string;
-	pages: { [x: string]: unknown };
 	description: string;
 	author: string;
 	publication: string;

lib/utils.ts

···
 import {
 	PubLeafletBlocksHeader,
 	PubLeafletBlocksText,
-	type PubLeafletDocument,
 	PubLeafletPagesLinearDocument,
 } from "./lexicons/index.js";
 import type {
···
 		);
 	}
 
-	return response?.data?.records;
+	return {
+		documents: response?.data?.records,
+		cursor: response?.data?.cursor,
+	};
 }
 
 export async function getSingleLeafletDocument({
···
 		rkey: uriToRkey(uri),
 		cid,
 		title: value.title,
-		pages: value.pages,
 		description: value.description,
 		author: value.author,
 		publication: value.publication,
···
 	id: string;
 	uri: string;
 	cid: string;
-	value: PubLeafletDocument.Main;
+	value: LeafletDocumentRecord;
 }) {
 	let html = "";
 	const firstPage = record.value.pages[0];

package.json

···
 	},
 	"scripts": {
 		"lint": "biome lint",
-		"format": "biome format --write ./src",
+		"format": "biome format --write ./lib",
 		"lex": "lex-cli generate -c ./lex.config.js",
 		"test": "vitest --run",
 		"typecheck": "tsc",