refactor how backlinks are stored

src/components/BskyPost.svelte

···
 		allPosts,
 		pulsingPostId,
 		currentTime,
-		findBacklinksBy,
 		deletePostBacklink,
 		createPostBacklink,
 		router,
 		profiles,
-		handles
+		handles,
+		hasBacklink
 	} from '$lib/state.svelte';
 	import type { PostWithUri } from '$lib/at/fetch';
 	import { onMount, type Snippet } from 'svelte';
···
 {/snippet}
 
 {#snippet postControls(post: PostWithUri)}
-	{@const myRepost = findBacklinksBy(post.uri, repostSource, selectedDid!).length > 0}
-	{@const myLike = findBacklinksBy(post.uri, likeSource, selectedDid!).length > 0}
+	{@const myRepost = hasBacklink(post.uri, repostSource, selectedDid!)}
+	{@const myLike = hasBacklink(post.uri, likeSource, selectedDid!)}
 	{#snippet control({
 		name,
 		icon,

src/lib/following.ts

···
 import { type ActorIdentifier, type Did, type ResourceUri } from '@atcute/lexicons';
 import type { PostWithUri } from './at/fetch';
-import type { Backlink, BacklinksSource } from './at/constellation';
+import type { BacklinksSource } from './at/constellation';
 import { extractDidFromUri, repostSource } from '$lib';
 import type { AppBskyGraphFollow } from '@atcute/bluesky';
 
···
 ) => {
 	if (sort === 'conversational') {
 		if (Math.abs(statsB.conversationalScore! - statsA.conversationalScore!) > 0.1)
-			// sort based on conversational score
 			return statsB.conversationalScore! - statsA.conversationalScore!;
 	} else {
 		if (sort === 'active')
 			if (Math.abs(statsB.activeScore! - statsA.activeScore!) > 0.0001)
-				// sort based on activity
 				return statsB.activeScore! - statsA.activeScore!;
 	}
-	// use recent if scores are similar / we are using recent mode
 	return statsB.lastPostAt!.getTime() - statsA.lastPostAt!.getTime();
 };
 
-// Caching to prevent re-calculating stats for every render frame if data is stable
 const userStatsCache = new Map<
 	Did,
 	{ timestamp: number; stats: ReturnType<typeof _calculateStats> }
 >();
-const STATS_CACHE_TTL = 60 * 1000; // 1 minute
+const STATS_CACHE_TTL = 60 * 1000;
 
 export const calculateFollowedUserStats = (
 	sort: Sort,
···
 	interactionScores: Map<ActorIdentifier, number> | null,
 	now: number
 ) => {
-	// For 'active' sort which is computationally heavy, use cache
 	if (sort === 'active') {
 		const cached = userStatsCache.get(did);
 		if (cached && now - cached.timestamp < STATS_CACHE_TTL) {
 			const postsMap = posts.get(did);
-			// Simple invalidation check: if post count matches, assume cache is valid enough
-			// This avoids iterating the map just to check contents.
-			// Ideally we'd have a version/hash on the map.
 			if (postsMap && postsMap.size > 0) return { ...cached.stats, did };
 		}
 	}
···
 		if (ageMs < quarterPosts) recentPostCount++;
 		if (sort === 'active') {
 			const ageHours = ageMs / (1000 * 60 * 60);
-			// score = 1 / t^G
 			activeScore += 1 / Math.pow(ageHours + 1, gravity);
 		}
 	}
···
 	};
 };
 
-// weights
 const quoteWeight = 4;
 const replyWeight = 6;
 const repostWeight = 2;
···
 const halfLifeMs = 3 * oneDay;
 const decayLambda = 0.693 / halfLifeMs;
 
-// normalization constants
 const rateBaseline = 1;
 const ratePower = 0.5;
 const windowSize = 7 * oneDay;
 
-// Cache for post rates to avoid iterating every user's timeline every time
 const rateCache = new Map<Did, { rate: number; calculatedAt: number; postCount: number }>();
 
 const getPostRate = (did: Did, posts: Map<ResourceUri, PostWithUri>, now: number): number => {
 	const cached = rateCache.get(did);
-	// If cached and number of posts hasn't changed, return cached rate
 	if (cached && cached.postCount === posts.size && now - cached.calculatedAt < 5 * 60 * 1000)
 		return cached.rate;
 
···
 	user: Did,
 	followsMap: Map<ResourceUri, AppBskyGraphFollow.Main>,
 	allPosts: Map<Did, Map<ResourceUri, PostWithUri>>,
-	backlinks_: Map<ResourceUri, Map<BacklinksSource, Set<Backlink>>>,
-	replyIndex: Map<Did, Set<ResourceUri>>, // NEW: Inverted Index
+	allBacklinks: Map<BacklinksSource, Map<ResourceUri, Map<Did, Set<string>>>>,
+	replyIndex: Map<Did, Set<ResourceUri>>,
 	now: number
 ) => {
 	const scores = new Map<Did, number>();
···
 		return Math.exp(-decayLambda * age);
 	};
 
-	// Helper to add score
 	const addScore = (did: Did, weight: number, time: number) => {
 		const current = scores.get(did) ?? 0;
 		scores.set(did, current + weight * decay(time));
 	};
 
-	// 1. Process MY posts (Me -> Others)
-	// This is relatively cheap as "my posts" are few compared to "everyone's posts"
+	// 1. process my posts (me -> others)
 	const myPosts = allPosts.get(user);
 	if (myPosts) {
 		const seenRoots = new Set<ResourceUri>();
 		for (const post of myPosts.values()) {
 			const t = new Date(post.record.createdAt).getTime();
 
-			// If I replied to someone
 			if (post.record.reply) {
 				const parentUri = post.record.reply.parent.uri;
 				const rootUri = post.record.reply.root.uri;
···
 				}
 			}
 
-			// If I quoted someone
 			if (post.record.embed?.$type === 'app.bsky.embed.record') {
 				const targetDid = extractDidFromUri(post.record.embed.record.uri);
 				if (targetDid && targetDid !== user) addScore(targetDid, quoteWeight, t);
···
 		}
 	}
 
-	// 2. Process OTHERS -> ME (using Index)
-	// Optimized: Use replyIndex instead of iterating all follows
+	// 2. process others -> me (using reply index)
 	const repliesToMe = replyIndex.get(user);
 	if (repliesToMe) {
 		for (const uri of repliesToMe) {
 			const authorDid = extractDidFromUri(uri);
-			if (!authorDid || authorDid === user) continue; // Self-reply
+			if (!authorDid || authorDid === user) continue;
 
 			const postsMap = allPosts.get(authorDid);
 			const post = postsMap?.get(uri);
-			if (!post) continue; // Post data not loaded?
+			if (!post) continue;
 
 			const t = new Date(post.record.createdAt).getTime();
 			addScore(authorDid, replyWeight, t);
 		}
 	}
 
-	for (const [uri, backlinks] of backlinks_) {
-		const targetDid = extractDidFromUri(uri);
-		if (!targetDid || targetDid !== user) continue; // Only care about interactions on MY posts
+	// 3. process reposts on my posts
+	const repostBacklinks = allBacklinks.get(repostSource);
+	if (repostBacklinks && myPosts) {
+		for (const [uri, myPost] of myPosts) {
+			const didMap = repostBacklinks.get(uri);
+			if (!didMap) continue;
 
-		const reposts = backlinks.get(repostSource);
-		if (reposts) {
+			const t = new Date(myPost.record.createdAt).getTime();
 			const adds = new Map<Did, { score: number; repostCount: number }>();
-			for (const repost of reposts) {
-				if (repost.did === user) continue;
-				const add = adds.get(repost.did) ?? { score: 0, repostCount: 0 };
+
+			for (const [did, rkeys] of didMap) {
+				if (did === user) continue;
+
+				let add = adds.get(did) ?? { score: 0, repostCount: 0 };
 				const diminishFactor = 9;
-				const weight = repostWeight * (diminishFactor / (add.repostCount + diminishFactor));
-				adds.set(repost.did, {
-					score: add.score + weight,
-					repostCount: add.repostCount + 1
-				});
-			}
 
-			// Get the timestamp of the post being reposted to calculate decay
-			// (Interaction timestamp is unknown for backlinks usually, so we use post timestamp as proxy or 'now'?
-			// Original code used `post.record.createdAt`.
-			const myPost = myPosts?.get(uri);
-			if (myPost) {
-				const t = new Date(myPost.record.createdAt).getTime();
-				for (const [did, add] of adds.entries()) addScore(did, add.score, t);
+				// each rkey is a separate repost record, apply diminishing returns
+				for (let i = 0; i < rkeys.size; i++) {
+					const weight = repostWeight * (diminishFactor / (add.repostCount + diminishFactor));
+					add = {
+						score: add.score + weight,
+						repostCount: add.repostCount + 1
+					};
+				}
+				adds.set(did, add);
 			}
+
+			for (const [did, add] of adds.entries()) addScore(did, add.score, t);
 		}
 	}
 
-	// Apply normalization
+	// normalize by posting rate
 	for (const [did, score] of scores) {
 		const posts = allPosts.get(did);
 		const rate = posts ? getPostRate(did, posts, now) : 0;

src/lib/state.svelte.ts

···
 export const profiles = new SvelteMap<Did, AppBskyActorProfile.Main>();
 export const handles = new SvelteMap<Did, Handle>();
 
-export type BacklinksMap = SvelteMap<BacklinksSource, SvelteSet<Backlink>>;
-export const allBacklinks = new SvelteMap<ResourceUri, BacklinksMap>();
+// source -> subject -> did (who did the interaction) -> rkey
+export type BacklinksMap = SvelteMap<
+	BacklinksSource,
+	SvelteMap<ResourceUri, SvelteMap<Did, SvelteSet<RecordKey>>>
+>;
+export const allBacklinks: BacklinksMap = new SvelteMap();
 
 export const addBacklinks = (
 	subject: ResourceUri,
 	source: BacklinksSource,
 	links: Iterable<Backlink>
 ) => {
-	let postsMap = allBacklinks.get(subject);
-	if (!postsMap) {
-		postsMap = new SvelteMap();
-		allBacklinks.set(subject, postsMap);
+	let subjectMap = allBacklinks.get(source);
+	if (!subjectMap) {
+		subjectMap = new SvelteMap();
+		allBacklinks.set(source, subjectMap);
 	}
-	let backlinksSet = postsMap.get(source);
-	if (!backlinksSet) {
-		backlinksSet = new SvelteSet();
-		postsMap.set(source, backlinksSet);
+
+	let didMap = subjectMap.get(subject);
+	if (!didMap) {
+		didMap = new SvelteMap();
+		subjectMap.set(subject, didMap);
 	}
+
 	for (const link of links) {
-		backlinksSet.add(link);
-		// console.log(
-		// 	`added backlink at://${link.did}/${link.collection}/${link.rkey} to ${subject} from ${source}`
-		// );
+		let rkeys = didMap.get(link.did);
+		if (!rkeys) {
+			rkeys = new SvelteSet();
+			didMap.set(link.did, rkeys);
+		}
+		rkeys.add(link.rkey);
 	}
 };
 
···
 	source: BacklinksSource,
 	links: Iterable<Backlink>
 ) => {
-	const postsMap = allBacklinks.get(subject);
-	if (!postsMap) return;
-	const backlinksSet = postsMap.get(source);
-	if (!backlinksSet) return;
-	for (const link of links) backlinksSet.delete(link);
+	const didMap = allBacklinks.get(source)?.get(subject);
+	if (!didMap) return;
+
+	for (const link of links) {
+		const rkeys = didMap.get(link.did);
+		if (!rkeys) continue;
+		rkeys.delete(link.rkey);
+		if (rkeys.size === 0) didMap.delete(link.did);
+	}
 };
 
-export const findBacklinksBy = (
-	subject: ResourceUri,
-	source: BacklinksSource,
-	did: Did
-): Backlink[] => {
-	const postsMap = allBacklinks.get(subject);
-	if (!postsMap) return [];
-	const backlinksSet = postsMap.get(source);
-	if (!backlinksSet) return [];
-	return Array.from(backlinksSet.values().filter((link) => link.did === did));
+export const findBacklinksBy = (subject: ResourceUri, source: BacklinksSource, did: Did) => {
+	const rkeys = allBacklinks.get(source)?.get(subject)?.get(did) ?? [];
+	// reconstruct the collection from the source
+	const collection = source.split(':')[0] as Nsid;
+	return rkeys.values().map((rkey) => ({ did, collection, rkey }));
+};
+
+export const hasBacklink = (subject: ResourceUri, source: BacklinksSource, did: Did): boolean => {
+	return allBacklinks.get(source)?.get(subject)?.has(did) ?? false;
+};
+
+export const getAllBacklinksFor = (subject: ResourceUri, source: BacklinksSource): Backlink[] => {
+	const subjectMap = allBacklinks.get(source);
+	if (!subjectMap) return [];
+
+	const didMap = subjectMap.get(subject);
+	if (!didMap) return [];
+
+	const collection = source.split(':')[0] as Nsid;
+	const result: Backlink[] = [];
+
+	for (const [did, rkeys] of didMap)
+		for (const rkey of rkeys) result.push({ did, collection, rkey });
+
+	return result;
+};
+
+export const isBlockedBy = (subject: Did, blocker: Did): boolean => {
+	return hasBacklink(`at://${subject}`, 'app.bsky.graph.block:subject', blocker);
 };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any